ToolActToolAct

Herramienta de Escape JSON

Escapa y desescapa rápidamente cadenas JSON

Entrada
Caracteres: 0
Bytes: 0
Salida
Caracteres: 0
Bytes: 0

Selecciona Método de Conversión

¿Qué es el Escape JSON?

El escape JSON es el proceso de convertir caracteres especiales en cadenas JSON a secuencias de escape. Los caracteres de escape comunes incluyen: " a \", \\ a \\\\, saltos de línea a \n, tabuladores a \t, etc.

Casos de uso: Cuando necesitas incrustar JSON dentro de otra cadena JSON, definir constantes de cadena JSON en código, o almacenar datos JSON en una base de datos, se requiere escape.

El escape JSON prepara texto para colocarlo de forma segura dentro de una cadena JSON. Comillas, barras invertidas, saltos de línea, tabs y caracteres de control deben escaparse correctamente o el parser puede tratarlos como estructura en vez de contenido. Sirve para payloads de API, valores de configuración, logs, mensajes de error embebidos y datos de prueba. Escapar una cadena no valida todo el documento JSON ni vuelve el resultado seguro para HTML, JavaScript, SQL o shell.

Cómo usar

Cómo usar

  1. Pega o introduce texto en el cuadro de entrada
  2. Pulsa 'Escape JSON' para escapar caracteres especiales (p. ej., ' a \')
  3. Pulsa 'Desescapar JSON' para revertir los caracteres escapados (p. ej., \' a ')
  4. Los resultados aparecen automáticamente abajo, listos para copiar

Notas sobre el escapado

  • Escapa el texto solo para el contexto de destino: las cadenas JSON, el código fuente JavaScript, las URL y los atributos HTML tienen reglas de escapado distintas.
  • Tras desescapar, revisa los saltos de línea, las barras invertidas y las comillas antes de pegar en archivos de configuración.

Casos de uso

Incrustar texto de forma segura dentro de cadenas JSONCuando un mensaje de error, fragmento de SQL, expresión regular, ruta de Windows o prompt multilínea debe convertirse en un valor de cadena JSON, el modo de escape transforma comillas, barras invertidas, saltos de línea y caracteres de control en secuencias seguras para JSON. Los recuentos de caracteres y bytes ayudan a detectar el crecimiento del payload antes de pegarlo en una solicitud de API. Todo se procesa en el navegador mediante JSON.stringify, por lo que el texto original nunca sale de la página.
Leer payloads escapados procedentes de logsLos gateways de API y sistemas de registro suelen mostrar valores de cadenas JSON con saltos de línea y comillas escapados. El modo de desescape convierte esas secuencias en texto legible, facilitando la inspección de trazas de pila, prompts serializados, cuerpos de webhooks y valores de configuración copiados. El desescape usa la ruta JSON.parse del navegador, por lo que los caracteres reconstruidos permanecen locales y solo aparecen en el campo de salida hasta que los copies.
Verificar texto complejo de forma localDado que la herramienta se basa en el parser y serializador JSON del navegador, refleja las reglas estándar de escape de cadenas JSON en lugar de inventar una convención propia. Esto la convierte en un borrador local útil para comprobar si un valor sobrevivirá al ser colocado dentro de un documento JSON. El texto de entrada se procesa solo en el navegador, sin llamadas a la API, por lo que los borradores que incluyen trazas de pila, prompts o textos sin publicar nunca cruzan la red.
Escapar valores para incluirlos en un campo JSON dentro de JSONCuando un payload de webhook debe llevar un objeto JSON serializado como valor de un campo de cadena, pasa el JSON interno por el modo de escape para que el parser externo lo siga leyendo como una sola cadena. Combina la salida con un pase de desescape en el receptor para confirmar la integridad de la conversión antes de publicar el contrato. Al ser un escape local con stringify, puedes probar casos límite como comillas anidadas o secuencias \u incrustadas sin exponer el contrato a herramientas externas.
Detectar caracteres de control ocultos en texto copiadoEl texto pegado desde terminales, PDFs o aplicaciones de chat suele contener bytes NUL, BEL o caracteres CR sueltos que rompen silenciosamente los parsers JSON posteriores. El escape los muestra como secuencias \u0000 para que puedan revisarse y eliminarse, en lugar de convertir el documento en un bloque inválido. El análisis se ejecuta completamente contra el codificador JSON de la página, por lo que las cadenas pegadas con fragmentos privados se muestran y reescriben sin salir de la pestaña del navegador.

Principio técnico

JSON (RFC 8259) es una gramática de texto estricta; todo literal de cadena debe ir entre comillas dobles ASCII (U+0022), y cualquier carácter que pueda romper esa gramática debe expresarse como una secuencia de escape con barra invertida. Los escapes obligatorios son: comillas dobles a barra invertida-comilla, barra invertida a doble barra invertida, y los 32 caracteres de control desde U+0000 hasta U+001F (que incluyen \b U+0008, \f U+000C, \n U+000A, \r U+000D, \t U+0009). Cualquier carácter por encima de U+001F puede aparecer en la cadena como su secuencia de bytes UTF-8 sin procesar, incluidos ideogramas CJK, emoji, letras acentuadas y otros caracteres suplementarios. El carácter de barra diagonal es opcional escapar (\/), pero la convención es escaparlo cuando el JSON está incrustado dentro de etiquetas HTML <script>, para que la secuencia de cierre de etiqueta script no cierre prematuramente el elemento script circundante. En la práctica aparecen dos capas de escape. El escape JSON (la sustitución sintáctica) es el único que requiere RFC 8259: garantiza que la cadena sea JSON válido, sin más. El escape Unicode (reescribir cada carácter como \uXXXX o \u{XXXXX}) es una elección representativa, no un requisito sintáctico, solo cambia cómo se ven los bytes en el archivo, no lo que decodifican. El texto CJK ya es válido en JSON como bytes UTF-8 sin procesar; el modo de escape Unicode de la página lo reescribe como \uXXXX, lo cual es útil al introducir la cadena en un archivo fuente Java o JavaScript donde el parser tendría que lidiar con UTF-8 multibyte, pero añade 4-6 bytes por carácter y dificulta la legibilidad. Las reglas de escape tienen casos límite. JSON.parse es estricto con los ceros a la izquierda (01 es un error de análisis, aunque JavaScript lo aceptaría como octal 1); JSON.stringify en V8 siempre produce escapes mínimos necesarios (caracteres de control como \b/\n/\r/\t/\f cuando es posible, de lo contrario como \uXXXX, y la barra diagonal /, U+2028, U+2029 se dejan sin procesar para una salida legible). Un sustituto solitario (un sustituto alto no seguido de uno bajo) es técnicamente JSON válido según RFC 8259, pero JSON.parse en modo estricto o en TypeScript lo rechaza como InvalidString; el modo de escape de la página reemplaza los sustitutos solitarios por \uFFFD (carácter de reemplazo) para que la salida pueda hacer un ida y vuelta con cualquier parser estándar. Para incrustación en código fuente JavaScript, la cadena JSON necesita una tercera capa de escape: JSON dentro de un literal de cadena JS debe escapar las propias barras invertidas. El modo de salida de cadena JS de la página añade ese doble escape, y el botón de eval o JSON.parse muestra que ambas codificaciones decodifican a la misma cadena. Los contextos incrustados en HTML añaden una cuarta capa: <, >, & necesitan escape de entidades HTML en la página circundante, y los valores de atributos también necesitan escape de comillas. JSON en HTML es famosamente peligroso (el problema de </script> mencionado antes) y es mejor evitarlo en favor de destinos seguros como la asignación de textContent o JSON.stringify dentro de un bloque <script type="application/json"> (leído después mediante script.textContent, nunca con eval). JSON5 (un superconjunto popular) añade cadenas entre comillas simples, cadenas multilínea, claves sin comillas, comas finales, NaN/Infinity y comentarios de una sola línea //. La página no produce salida JSON5; si necesitas hacer un ida y vuelta, usa una biblioteca dedicada.

  • Las cadenas JSON (RFC 8259) deben escapar comillas dobles a barra invertida-comilla, barra invertida a doble barra invertida, y los 32 caracteres de control U+0000..U+001F (\b \f \n \r \t, más el resto como \uXXXX). Todo lo que esté por encima de U+001F es UTF-8 sin procesar válido, incluidos CJK, emoji y letras acentuadas.
  • Aparecen dos capas de 'escape': el escape JSON (sintáctico, obligatorio) hace que la cadena sea JSON válido; el escape Unicode (representativo) reescribe caracteres como \uXXXX y solo cambia la legibilidad, no la validez.
  • '/' opcional: / a \/ está permitido en JSON. Convención: escaparlo al incrustar JSON en HTML <script> para que la secuencia de cierre de etiqueta script no cierre la etiqueta circundante.
  • El CJK no se escapa en JSON UTF-8 sin procesar: el ejemplo '你好' son 6 bytes sin procesar. El modo de escape Unicode de la página lo reescribe como \u4f60\u597d para usar en archivos fuente, sacrificando legibilidad por compatibilidad.
  • Sustitutos solitarios: un sustituto alto (U+D800..U+DBFF) no seguido de uno bajo es técnicamente JSON válido según RFC 8259, pero JSON.parse en modo estricto o TypeScript lo rechaza. La página reemplaza los sustitutos solitarios por \uFFFD para que la salida pueda hacer un ida y vuelta con parsers estrictos.
  • JSON.parse es estricto: los ceros a la izquierda (01) son un error de análisis, NaN/Infinity no son literales válidos, las comas finales no están permitidas. JSON.stringify en V8 siempre produce escapes mínimos necesarios y deja la barra diagonal / y U+2028/U+2029 sin procesar para legibilidad.
  • JSON en JS: para incrustar una cadena JSON en un literal de cadena JS, duplica las barras invertidas. La salida 'cadena JS' de la página añade esa capa; eval sobre el resultado da la misma cadena que JSON.parse.
  • Superconjunto JSON5: cadenas entre comillas simples, cadenas multilínea, claves sin comillas, comas finales, NaN/Infinity, comentarios de una sola línea //. La página produce JSON estricto RFC 8259, no JSON5.

Ejemplos

Cadenas con comillas dobles y barras invertidas

Entrada: He said "Hello\World"
Salida:  He said \"Hello\\World\"

Cadenas con saltos de línea y tabulaciones

Entrada: Line1\tIndent\nLine2
Salida:  Line1\tIndent\nLine2

Cadenas con chino y comillas dobles

Entrada: {"name": "Alice", "msg": "He said \"Hi\""}
Salida:  {\"name\": \"Alice\", \"msg\": \"He said \\\"Hi\\\"\"}

Preguntas frecuentes

¿Qué hace escapar una cadena JSON?

Envuelve la entrada entre comillas y reemplaza cada carácter especial por su secuencia de escape válida en JSON: " → \", \ → \\, salto de línea → \n, tabulación → \t, caracteres de control → \u00NN. El resultado es un literal de cadena JSON válido que puedes pegar en otro documento JSON o en un editor de código.

¿Cuándo lo necesitaría?

Casos típicos: incrustar un mensaje multilínea dentro de un archivo de configuración JSON, pasar una cadena JSON como argumento de línea de comandos, meter JSON dentro de JSON (por ejemplo, un cuerpo de petición de API que es a su vez una cadena JSON codificada) o sanear entrada de usuario antes de registrarla.

¿Escapar es lo mismo que codificar URL?

No. El escape JSON usa \n, \", \u00XX. La codificación URL usa %20, %22, %0A. Contextos sintácticos distintos, reglas de escape distintas. Usa la que coincida con el formato de destino.

¿El modo unescape gestiona todos los escapes JSON?

Sí: todos los escapes estándar (\", \\, \/, \b, \f, \n, \r, \t, \uXXXX). Los pares suplentes (surrogate pairs) para puntos de código por encima de U+FFFF (\uD83D\uDE00 = 😀) se reensamblan en el emoji real. Las secuencias de escape malformadas producen un error que puedes corregir.

¿Cuál es la diferencia entre escapar una cadena y serializar un objeto?

Escapar convierte un fragmento de texto en una cadena JSON entre comillas. Serializar (JSON.stringify) convierte un objeto JavaScript en un documento JSON completo. Esta página hace lo primero; para lo segundo, escribe el objeto como JSON en tu editor de código o usa un formateador JSON.

¿Los caracteres de control siempre se escapan?

Sí: JSON lo exige. Los saltos de línea, tabulaciones, NULL y otros caracteres de control ASCII (0x00-0x1F) deben escaparse o la cadena resultante no será JSON válido. Algunas implementaciones también escapan DEL (0x7F) y los caracteres por encima de U+FFFF; la página sigue estrictamente el RFC 8259.

¿Se envían los datos a algún sitio?

No. El escape y el unescape se ejecutan en tu navegador. El texto pegado no se sube.