Escapador de cadenas JS
Un texto con comillas y un salto de línea, como Hello "world" en dos líneas, se convierte en Hello \"world\"\nline 2, listo para pegar entre comillas dobles. Elija comillas dobles, simples o invertidas, o desescape una cadena para recuperar el texto. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Texto
- Hello "world" line 2
- Modo de cálculo
- Escape
- Comillas
- Double
- Resultado
- Hello \"world\"\nline 2
- Longitud
- 23
- Literal
- "Hello \"world\"\nline 2"
Incluir texto libre dentro de un literal de cadena JavaScript es un error habitual: una sola comilla doble cierra la cadena, una barra invertida se come el siguiente carácter, un salto de línea crudo es un error de sintaxis y pegar caracteres no ASCII puede romper herramientas antiguas que esperan \uXXXX. Este escapador de cadenas JavaScript convierte texto plano en un cuerpo de literal seguro (y en un literal entre comillas listo para pegar) y revierte el mismo mapa cuando necesita recuperar los caracteres originales. El modo escape respeta el estilo de comillas que elija —dobles, simples o backtick— junto con barras invertidas, los escapes de control habituales y, si lo desea, escapes unicode para cada punto de código no ASCII.
Cómo funcionan en la práctica los escapes de cadena en JavaScript
Un literal de cadena en JavaScript es una secuencia de caracteres entre comillas dobles, comillas simples o backticks. Dentro de esa secuencia, la barra invertida inicia un escape: \\ se convierte en una sola barra, \" o \' coincide con la comilla elegida, \n es un salto de línea, \r un retorno de carro, \t un tabulador, y formas cortas como \0, \b, \f y \v cubren otros controles.
Dos formas hexadecimales son estándar en motores modernos: \xHH codifica una unidad de código con dos dígitos hexadecimales y \uXXXX codifica una unidad UTF-16 con cuatro dígitos. ES6 también permite llaves al estilo \u{1F600} para cualquier punto de código Unicode hasta U+10FFFF, la forma limpia de representar caracteres fuera del plano multilingüe básico sin pares sustitutos a mano. Esta capacidad aplica esas reglas de forma determinista.
En modo escape recorre cada unidad de código, sustituye caracteres especiales por el escape seguro más corto para el estilo de comillas seleccionado, siempre escapa U+2028 y U+2029 para que un pegado multilínea no rompa líneas de código, y opcionalmente reescribe cada carácter no ASCII a \uXXXX o \u{…} cuando unicode es true. En modo unescape analiza las mismas secuencias y rechaza barras finales, formas \x o \u incompletas, \u{} vacíos, puntos de código fuera de rango y escapes octales legados que solo existen en modos Annex B relajados.
Dónde un escapador de cadenas JS aporta valor real
Los sitios de documentación y recetas con ejemplos copiables necesitan una vía de escape fiable para que las muestras del usuario sigan siendo JavaScript válido. Los equipos de soporte y seguridad pegan fragmentos de registros que ya contienen escapes con barra invertida y necesitan un desescape que falle en voz alta ante secuencias \u truncadas en lugar de inventar caracteres. Los ingenieros de localización comprueban que los idiomas multibyte hagan ida y vuelta cuando se fuerza el modo unicode en repositorios solo ASCII.
Quienes enseñan la sintaxis de cadenas de ECMAScript quieren una página dedicada a escapes de literales, no enterrada bajo una herramienta genérica de Base64 o entidades HTML, porque la intención de búsqueda y el conjunto de escapes permitido difieren. Si necesita entidades HTML, codificación porcentual de URL o análisis completo de JavaScript, trátelos como intenciones de búsqueda y landings distintas en lugar de sobrecargar esta página de escapado de cadenas.
Qué puede hacer con ella
Literales de cadena seguros en código generado
Escape títulos, mensajes y valores de configuración de texto libre antes de escribirlos en JavaScript con comillas dobles, simples o literales de plantilla.
Reescritura unicode solo ASCII
Escape con unicode true para que los caracteres no ASCII pasen a secuencias \uXXXX o \u{…} aptas para repositorios solo ASCII y cadenas de herramientas antiguas.
Preguntas frecuentes
¿Cuál es la diferencia entre result y literal?
Result es el cuerpo escapado sin comillas envolventes. Literal (solo en modo escape) envuelve ese cuerpo con el estilo de comillas elegido para que pueda pegar una cadena JavaScript completa en el código fuente.
¿Puedo escapar y desescapar?
Sí. Establezca mode en escape (predeterminado) para codificar texto plano, o mode en unescape para recuperar el texto desde un cuerpo de literal de cadena JavaScript.
¿Qué estilos de comillas se admiten?
Dobles (predeterminado), simples y backtick. El modo escape solo escapa el delimitador que eligió; el modo backtick también escapa ${ para que el cuerpo sea seguro dentro de un literal de plantilla.
¿Qué ocurre si una secuencia de escape está mal formada?
No se cobra nada por fallos de validación.
¿Cuánto cuesta?
La herramienta del navegador es gratuita y se ejecuta en local.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/enc/js-string-escape \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello \"world\"\nline 2"}'const res = await fetch("https://api.kit.forhosting.com/enc/js-string-escape", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello \"world\"\nline 2"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/js-string-escape",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello \"world\"\nline 2"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/js-string-escape", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello \\"world\\"\\nline 2"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello \"world\"\nline 2"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/js-string-escape", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"text": "Hello \"world\"\nline 2"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.js_string_escape",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
El modo unescape entiende \n, \r, \t, \\ , \xHH, \uXXXX y \u{…}, y falla de inmediato con invalid_input ante secuencias truncadas o ilegales en lugar de inventar basura a medio decodificar.
Cómo funcionan en la práctica los escapes de cadena en JavaScript
El camino es trabajo puro de cadenas sin red, sin semillas aleatorias y sin reloj de pared, así que entradas idénticas siempre producen el mismo JSON. El precio de las llamadas API correctas es la base publicada de $0.002 por ítem, y los fallos de validación no consumen saldo prepago.
Qué envía usted y qué recibe a cambio
El modo escape convierte texto plano en un cuerpo de literal JavaScript guardado en result y también devuelve literal: el mismo cuerpo entre las comillas elegidas para pegarlo en el código fuente. El modo unescape invierte las secuencias de escape de text y devuelve la cadena plana recuperada en result sin campo literal. Quote vale double por defecto; use single o backtick cuando la sintaxis de destino use esos delimitadores: el escape solo fuerza el escape de ese delimitador (y, con backticks, de la secuencia ${ que abriría una interpolación). Comprobaciones clásicas: escapar un saludo con comillas incrustadas y un salto de línea, desescapar un cuerpo que usa \u00E9 para é, escapar con unicode true para que café pase a caf\u00E9, y rechazar una cadena que termina en una barra sola. Envíe un campo de cadena obligatorio llamado text y campos opcionales mode, quote y unicode. Si omite mode, escape es el valor predeterminado y un solo payload sigue siendo útil. La respuesta repite mode, quote, unicode, el text original, result y la length de result. La falta de text, objetos que no son cadenas, valores de mode o quote no admitidos, valores que no se leen como booleano para unicode, cadenas más largas que el máximo documentado, barras finales, escapes hex incompletos, dígitos no hex, escapes con llaves vacíos, puntos de código ilegales y formas octales rechazadas fallan con invalid_input y un mensaje claro en inglés. Los fallos de validación no consumen saldo prepago. El precio de la API con éxito es la base publicada de $0.002 por ítem.
Dónde un escapador de cadenas JS aporta valor real
Como esta capacidad es un motor parse puro, el precio de la API es la base publicada de $0.002 por ítem con éxito y la validación fallida no consume saldo.
Casos de integración
Decodificar cuerpos escapados de registros y fixtures
Desescape cuerpos de cadenas JavaScript desde registros, tickets y archivos golden a texto legible, con fallos duros ante escapes incompletos o ilegales.