Des-escape de JSON

¿Qué es el des-escape JSON?

// Escaped input (copied from a log, quotes optional)
User said: \"it works!\"\nSession ended.

// Unescaped output — readable again
User said: "it works!"
Session ended.

// \uXXXX and surrogate pairs decode too
caf\u00e9 \ud83d\ude00  ->  café 😀

// JSON-in-JSON
{\"a\":1}  ->  {"a":1}

Características principales

Ejemplos

"User said: \"it works!\"\nSession ended."

{\"event\":\"signup\",\"user\":{\"id\":42}}

caf\u00e9 \ud83d\ude00 r\u00e9sum\u00e9

function greet(name) {\n  return \"Hi \" + name;\n}

Cómo usar

1. 1

   Pega la cadena escapada

   Introduce o pega una cadena JSON escapada, con o sin las comillas dobles que la rodean. El texto decodificado aparece al instante. Pulsa 'Cargar ejemplo' para probar una muestra como una línea de log escapada o una cadena codificada con \uXXXX.

2. 2

   Lee la salida decodificada

   Las secuencias de escape se vuelven caracteres reales: \n se convierte en saltos de línea, \" en comillas y \uXXXX en Unicode. Si la entrada está mal formada, un banner de error explica el problema para que puedas corregir la barra invertida culpable.

3. 3

   Copia o verifica el resultado

   Pulsa Copiar para tomar el texto legible, o envíalo al Formateador JSON para validarlo. Pulsa Invertir dirección para reescaparlo en el sitio y confirmar que la ida y vuelta coincide con tu original.

Errores comunes de decodificación

value: \q and \x41
// \q and \x hex are not valid JSON escapes -> error

value: \\q and \u0041
// literal backslash doubled; hex written as \u -> decodes

say "hi" there
// interior unescaped " breaks auto-wrapping -> error

say \"hi\" there
// interior quotes escaped -> decodes to: say "hi" there

path: C:\Users\Alice
// \U and \A are invalid escapes -> error

path: C:\\Users\\Alice
// doubled backslashes -> decodes to C:\Users\Alice

Casos de uso comunes

Decodificar campos de log estructurados

Copia un campo de mensaje lleno de \n y \" de una línea de log JSON y des-escápalo para leer el mensaje multilínea real exactamente como se emitió, en lugar de entornar los ojos ante las secuencias de escape.

Leer payloads JSON-en-JSON

Convierte un objeto JSON interno que se almacenó como campo de cadena escapada de vuelta en JSON real, para que puedas leerlo o pegarlo en un analizador: común en sobres de webhooks y logs de auditoría.

Restaurar Unicode desde salida segura en ASCII

Decodifica una salida cargada de \uXXXX de un sistema heredado de vuelta a letras acentuadas, caracteres CJK y emoji, recuperando la forma legible de datos que fueron forzados a ASCII puro.

Desaplanar fragmentos de código

Convierte un script o consulta que fue colapsado en una única cadena JSON (cada salto de línea como \n) de vuelta en código con formato correcto, multilínea y legible.

Depurar datos doblemente codificados

Cuando un valor parece \\n o \\\", des-escapa una vez para inspeccionar si se escapó por accidente dos veces aguas arriba, luego corrige el productor: un error de integración frecuente.

Inspeccionar mensajes de error de API

Muchas API devuelven detalles de error como cadenas escapadas dentro de un sobre JSON. Des-escapa el mensaje para leer trazas de pila y payloads anidados que de otro modo quedan ocultos tras las secuencias de escape.

Detalles técnicos

Algoritmo de decodificación

La herramienta analiza la entrada como una cadena JSON: si ya está envuelta en comillas dobles se decodifica tal cual; de lo contrario, la entrada sin procesar se envuelve primero en comillas para que un cuerpo escapado desnudo también se decodifique. Cada escape reconocido (\n \r \t \b \f \" \\ \/ \uXXXX) se asigna a su carácter; esto refleja un analizador JSON conforme, garantizando que cualquier cadena escapada por un serializador vuelva a su original exacto.

Reconstrucción de pares sustitutos

Un escape \uXXXX produce una única unidad de código UTF-16. Cuando un sustituto alto (\uD800–\uDBFF) va inmediatamente seguido de un sustituto bajo (\uDC00–\uDFFF), los dos se combinan en un punto de código por encima del Plano Multilingüe Básico: así \ud83d\ude00 se decodifica en el único carácter 😀 en lugar de dos mitades rotas.

Validación y manejo de errores

Si la entrada contiene un escape no válido (una barra invertida seguida de un carácter no reconocido, o una secuencia \u mal formada) o comillas desequilibradas que rompen el envoltorio, la decodificación falla limpiamente y se muestra un banner de error en lugar de emitir una salida corrupta. La entrada válida siempre produce la cadena decodificada exacta; la entrada no válida nunca produce un resultado parcial engañoso.

Buenas prácticas

Pega con o sin comillas: ambas funcionan

No pierdas tiempo recortando las comillas que rodean. La herramienta decodifica "hello\nworld" y hello\nworld de forma idéntica, así que pega lo que copiaste —incluido un fragmento extraído del medio de un documento más grande— y lee el resultado.

Des-escapa una vez, luego comprueba la doble codificación

Si la salida decodificada sigue mostrando secuencias de barra invertida como \n, el original fue doblemente escapado aguas arriba. Des-escapa una segunda vez para confirmarlo, luego corrige el productor para que escape solo una vez en lugar de depender de la decodificación repetida.

Valida el JSON decodificado

Tras des-escapar un payload JSON-en-JSON, pasa el resultado por nuestro Formateador JSON para confirmar que es válido y formatearlo. El des-escape recupera el texto; el formateador confirma la estructura.

Verifica las idas y vueltas con Invertir

Pulsa Invertir dirección para reescapar el texto decodificado y comprobar que coincide con la cadena con la que empezaste. Una discrepancia apunta a una entrada mal formada o un escape inesperado, sacando a la luz problemas de datos antes de que se propaguen.

Preguntas frecuentes