El escape de cadenas JSON es el proceso de convertir caracteres especiales dentro de una cadena en secuencias de escape que los analizadores JSON pueden leer sin romper la estructura. La especificación JSON (ECMA-404 / RFC 8259) exige que ciertos caracteres dentro de los valores de cadena vayan precedidos de una barra invertida. Sin un escapado correcto, una comilla doble literal o un salto de línea dentro de una cadena terminaría la cadena prematuramente y produciría un error de análisis.
Toda cadena JSON está delimitada por comillas dobles. Cuando la cadena contiene una comilla doble, una barra invertida o un carácter de control (U+0000 a U+001F), el carácter debe reemplazarse por su secuencia de escape. Por ejemplo, un salto de línea literal se convierte en \n, un tabulador en \t y una comilla doble en \". Cualquier punto de código Unicode también puede representarse como \uXXXX, donde XXXX es el valor hexadecimal de cuatro dígitos.
Desescapar (la operación inversa) convierte esas secuencias de barra invertida de vuelta a los caracteres originales. Úsalo cuando recibes un payload JSON donde los valores de cadena están doblemente escapados, o cuando necesitas extraer texto sin procesar de una entrada de log JSON para mostrarlo en una interfaz o terminal. Los pipelines de agregación de logs se encuentran con esto constantemente: cuando un mensaje codificado en JSON se almacena como valor de cadena dentro de otro documento JSON, cada barra invertida de la cadena interna llega duplicada.
¿Por Qué Usar una Herramienta de Escape JSON?
Añadir o eliminar barras invertidas a mano es tedioso y propenso a errores, especialmente con texto multilínea, rutas de archivo o fragmentos de código embebidos. Una herramienta dedicada detecta los casos límite que la edición manual pasa por alto.
🔒
Procesamiento con privacidad garantizada
Tus cadenas nunca salen de tu navegador. Todo el escapado y desescapado se ejecuta localmente en JavaScript sin llamadas al servidor, por lo que los datos sensibles como claves de API o tokens permanecen en tu máquina.
⚡
Conversión instantánea
Pega cualquier texto y obtén la salida JSON correctamente escapada en milisegundos. Sin esperar una ida y vuelta a un servidor remoto.
🛡️
Sin cuenta ni instalación
Abre la página y empieza a escapar. Sin formulario de registro, sin extensión de navegador, sin herramienta CLI que instalar. Funciona en cualquier dispositivo con un navegador moderno.
📋
Cobertura completa de caracteres
Gestiona todos los escapes requeridos por JSON: comillas dobles, barras invertidas, caracteres de control (U+0000 a U+001F) y secuencias Unicode incluyendo emoji y caracteres CJK.
Casos de Uso del Escape de Cadenas JSON
Desarrollo frontend
Escapa el contenido generado por el usuario antes de incluirlo en un payload JSON enviado mediante fetch o XMLHttpRequest. Previene peticiones malformadas cuando los usuarios escriben comillas, saltos de línea o emoji.
Trabajo con APIs backend
Construye cuerpos de respuesta JSON en lenguajes que no escapan cadenas automáticamente (scripts de shell, procedimientos almacenados SQL, motores de plantillas). Pega la cadena sin procesar y copia la versión escapada.
DevOps y configuración
Incrusta bloques PEM de certificados multilínea, claves SSH o scripts de shell en archivos de configuración JSON para Terraform, CloudFormation o ConfigMaps de Kubernetes sin romper la estructura JSON.
QA y pruebas
Crea fixtures de prueba que incluyan caracteres límite: tabuladores, bytes nulos, pares sustitutos Unicode y cadenas escapadas anidadas. Verifica que tu analizador los gestiona correctamente.
Ingeniería de datos
Limpia entradas de log doblemente escapadas de Elasticsearch, CloudWatch o Datadog. Desescapa la cadena para recuperar el mensaje original para su análisis o re-ingesta.
Aprendizaje de JSON
Observa exactamente qué caracteres requieren escapado según la especificación JSON. Útil para estudiantes que trabajan con ECMA-404 o construyen su propio analizador JSON.
Referencia de Secuencias de Escape JSON
La especificación JSON define exactamente dos escapes obligatorios (comilla doble y barra invertida) y seis secuencias de escape cortas para caracteres de control habituales. El resto de caracteres de control (U+0000 a U+001F) deben usar la forma \uXXXX. Los caracteres por encima de U+FFFF (como los emoji) pueden representarse como un par sustituto UTF-16: \uD83D\uDE00.
Carácter
Descripción
Forma escapada
"
Double quote
\"
\
Backslash
\\
/
Forward slash
\/ (optional)
\n
Newline (LF)
\n
\r
Carriage return
\r
\t
Tab
\t
\b
Backspace
\b
\f
Form feed
\f
U+0000–U+001F
Control characters
\u0000–\u001F
U+0080+
Non-ASCII (e.g. emoji)
\uXXXX or raw UTF-8
Escape JSON vs. Codificación JSON
Los desarrolladores a veces confunden escapar una cadena con codificar un documento JSON completo.
Escape de cadena
Opera sobre el texto dentro de un valor de cadena JSON. Reemplaza los caracteres especiales por secuencias de barra invertida para que la cadena siga siendo válida entre comillas dobles. Entrada: texto sin procesar. Salida: texto escapado (aún necesita comillas alrededor para ser JSON válido).
Codificación JSON (Serialización)
Convierte una estructura de datos completa (objetos, arrays, números, booleanos, nulos) en una representación de texto JSON. El escape de cadenas es un paso dentro de este proceso mayor. Entrada: una estructura de datos. Salida: un documento JSON completo.
Ejemplos de Código
Todos los lenguajes principales disponen de funciones integradas para esto. Ejemplos en JavaScript, Python, Go y jq:
JavaScript (browser / Node.js)
// JSON.stringify escapes a value and wraps it in quotes
JSON.stringify('Line 1\nLine 2') // → '"Line 1\\nLine 2"'
// To get just the inner escaped string (no surrounding quotes):
const escaped = JSON.stringify('She said "hello"').slice(1, -1)
// → 'She said \\"hello\\"'
// Parsing reverses the escaping
JSON.parse('"tabs\\tand\\nnewlines"') // → 'tabs\tand\nnewlines'
// Handling Unicode: emoji in JSON
JSON.stringify('Price: 5\u20ac') // → '"Price: 5\u20ac"' (raw euro sign)
Python
import json
# json.dumps escapes and quotes a string
json.dumps('Line 1\nLine 2') # → '"Line 1\\nLine 2"'
# Ensure ASCII: replace non-ASCII with \uXXXX sequences
json.dumps('Caf\u00e9', ensure_ascii=True) # → '"Caf\\u00e9"'
# Keep UTF-8 characters as-is (default in Python 3)
json.dumps('Caf\u00e9', ensure_ascii=False) # → '"Caf\u00e9"'
# Unescape by round-tripping through json.loads
json.loads('"She said \\"hello\\""') # → 'She said "hello"'
Go
package main
import (
"encoding/json"
"fmt"
)
func main() {
// json.Marshal escapes a Go string for JSON
raw := "Line 1\nLine 2\tindented"
b, _ := json.Marshal(raw)
fmt.Println(string(b))
// → "Line 1\nLine 2\tindented"
// Unescape with json.Unmarshal
var out string
json.Unmarshal([]byte(`"She said \"hello\""`), &out)
fmt.Println(out)
// → She said "hello"
}
CLI (jq)
# Escape a raw string into a JSON-safe value
echo 'Line 1
Line 2 with tab' | jq -Rs '.'
# → "Line 1\nLine 2\twith tab\n"
# Unescape a JSON string back to raw text
echo '"She said \"hello\""' | jq -r '.'
# → She said "hello"
Preguntas Frecuentes
¿Qué caracteres deben escaparse en una cadena JSON?
La especificación JSON (RFC 8259) exige escapar la comilla doble (\"), la barra invertida (\\) y todos los caracteres de control de U+0000 a U+001F. La barra diagonal (/) puede escaparse como \/ pero es opcional. El resto de caracteres Unicode, incluidos texto no ASCII y emoji, pueden aparecer sin escapar siempre que el documento use codificación UTF-8.
¿Cuál es la diferencia entre escape JSON y JSON stringify?
JSON.stringify() en JavaScript serializa un valor JavaScript completo en una cadena JSON, añadiendo comillas dobles alrededor y escapando los caracteres especiales en su interior. El escape JSON se refiere específicamente al reemplazo a nivel de carácter de los caracteres especiales por secuencias de barra invertida. Llamar a JSON.stringify() sobre una cadena realiza el escapado como parte del proceso de serialización.
¿Cómo escapo un salto de línea en JSON?
Reemplaza el carácter de salto de línea literal (U+000A) por la secuencia de dos caracteres \n. De igual modo, el retorno de carro (U+000D) se convierte en \r. Si usas JSON.stringify() o json.dumps() en Python, estos reemplazos se realizan automáticamente.
¿Por qué mi cadena JSON está doblemente escapada?
El doble escapado ocurre cuando una cadena se serializa dos veces. Por ejemplo, llamar a JSON.stringify() sobre una cadena que ya contiene secuencias de escape volverá a escapar las barras invertidas: \n se convierte en \\n. Para solucionarlo, analiza la cadena una vez con JSON.parse() antes de volver a serializarla, o revisa tu pipeline en busca de pasos de codificación redundantes.
¿Puedo usar comillas simples en cadenas JSON?
No. La especificación JSON exige comillas dobles para todos los valores de cadena y nombres de propiedad. Las comillas simples no son JSON válido y provocarán un error de análisis. Si tus datos de origen contienen comillas simples, no necesitan escaparse dentro de una cadena JSON con comillas dobles, ya que las comillas simples son caracteres ordinarios en ese contexto.
¿Es seguro incluir caracteres UTF-8 sin escapar en JSON?
Sí, siempre que el documento JSON esté codificado en UTF-8, que RFC 8259 especifica como la codificación predeterminada y recomendada. Caracteres como letras acentuadas, ideogramas CJK y emoji pueden aparecer directamente en la cadena sin escapado \uXXXX. Algunos sistemas más antiguos esperan JSON solo ASCII; en ese caso, usa la opción ensure_ascii en Python o una opción equivalente en tu lenguaje.
¿Cómo escapo emoji en JSON?
Los emoji por encima de U+FFFF se representan en JSON mediante un par sustituto UTF-16. Por ejemplo, la cara sonriente (U+1F600) se convierte en \uD83D\uDE00. La mayoría de los serializadores gestionan esto automáticamente. Si escribes JSON a mano o tus herramientas solo admiten el Plano Multilingüe Básico, usa la notación de par sustituto. De lo contrario, incluye el emoji directamente como carácter UTF-8.