ToolActToolAct

Ferramenta de Escape JSON

Rapidamente faça escape e unescape de strings JSON

Entrada
Caracteres: 0
Bytes: 0
Saída
Caracteres: 0
Bytes: 0

Selecione Método de Conversão

O que é Escape JSON?

Escape JSON é o processo de converter caracteres especiais em strings JSON para sequências de escape. Caracteres de escape comuns incluem: " para \", \\ para \\\\, novas linhas para \n, tabulações para \t, etc.

Casos de uso: Quando você precisa incorporar JSON dentro de outra string JSON, definir constantes de string JSON em código, ou armazenar dados JSON em banco de dados, escape é necessário.

O escape JSON prepara texto para ser colocado com segurança dentro de uma string JSON. Aspas, barras invertidas, quebras de linha, tabs e caracteres de controle precisam ser escapados corretamente, ou o parser pode tratá-los como estrutura em vez de conteúdo. Isso é útil em payloads de API, valores de configuração, logs, mensagens de erro embutidas e dados de teste. Escapar uma string não valida o documento JSON inteiro nem torna o resultado seguro para HTML, JavaScript, SQL ou shell.

Como Usar

Como usar

  1. Cole ou insira texto na caixa de entrada
  2. Clique em 'JSON Escape' para escapar caracteres especiais (por exemplo, aspas duplas viram \")
  3. Clique em 'JSON Unescape' para restaurar caracteres escapados (por exemplo, \" vira aspas duplas)
  4. Os resultados aparecem automaticamente abaixo, prontos para copiar

Observações sobre Escape

  • Faça o escape do texto apenas para o contexto de destino; strings JSON, código JavaScript, URLs e atributos HTML possuem regras de escape diferentes.
  • Após desfazer o escape, verifique quebras de linha, barras invertidas e aspas antes de colar em arquivos de configuração.

Casos de uso

Incorporar texto com segurança dentro de strings JSONQuando uma mensagem de erro, fragmento SQL, regex, caminho Windows ou prompt de múltiplas linhas precisa se tornar um valor de string JSON, o modo de escape converte aspas, barras invertidas, quebras de linha e caracteres de controle em sequências seguras para JSON. A contagem de caracteres e bytes ajuda a perceber o crescimento do payload antes de colá-lo em uma requisição de API. Tudo é processado no navegador por meio do JSON.stringify padrão, então a string original nunca sai da página.
Ler payloads escapados em logsGateways de API e sistemas de logging frequentemente exibem valores de string JSON com quebras de linha e aspas escapadas. O modo unescape converte essas sequências de volta em texto legível, facilitando a inspeção de stack traces, prompts serializados, corpos de webhook e valores de configuração copiados. O unescape usa o JSON.parse do navegador, então os caracteres reconstruídos permanecem locais e só aparecem no campo de saída até que você os copie.
Testar ida e volta de textos complexos localmenteComo a ferramenta utiliza o parser e stringificador JSON do navegador, ela espelha as regras normais de escape de strings JSON em vez de inventar um dialeto personalizado. Isso a torna um bom bloco de rascunho local para verificar se um valor sobreviverá ao ser colocado dentro de um documento JSON. A string de entrada é processada apenas no navegador — nenhuma chamada de API é feita, então rascunhos que contêm stack traces, prompts ou cópias não publicadas nunca trafegam pela rede.
Escapar valores para inclusão em campos JSON-dentro-de-JSONQuando um payload de webhook precisa carregar um objeto JSON serializado como valor de um campo string, execute o JSON interno no modo de escape para que o parser externo ainda o leia como uma única string. Combine a saída com um passe de unescape no lado receptor para confirmar a integridade da conversão antes de publicar o contrato. Como o escape é um stringify local, você pode experimentar casos extremos como aspas aninhadas ou sequências \u incorporadas sem expor o contrato a ferramentas externas.
Detectar caracteres de controle ocultos em texto copiadoTextos colados de terminais, PDFs ou aplicativos de chat frequentemente contêm bytes NUL, BEL ou caracteres CR residuais que silenciosamente quebram parsers JSON. O escape revela esses caracteres como sequências no estilo \u0000 para que possam ser revisados e removidos, em vez de transformar o documento em um blob inválido. A varredura é executada inteiramente pelo codificador JSON da página, então strings coladas contendo trechos privados são reveladas e reescritas sem jamais sair da aba do navegador.

Princípio técnico

JSON (RFC 8259) é uma gramática textual estrita; todo literal de string deve ser envolvido em aspas duplas ASCII (U+0022), e qualquer caractere que possa quebrar essa gramática deve ser expresso como um escape com barra invertida. Os escapes obrigatórios são: aspas duplas para barra-invertida-aspas, barra invertida para barra-dupla, e os 32 caracteres de controle de U+0000 a U+001F (que incluem \b U+0008, \f U+000C, \n U+000A, \r U+000D, \t U+0009). Qualquer caractere acima de U+001F pode aparecer na string como sua sequência bruta de bytes UTF-8, incluindo ideogramas CJK, emoji, letras acentuadas e outros caracteres suplementários. O caractere barra para frente é opcional para escapar (\/), mas a convenção é escapá-lo quando o JSON está embutido em tags HTML <script>, para que a sequência de fechamento da tag script não feche prematuramente o elemento script circundante. Na prática, aparecem duas camadas de escape. O escape JSON (a substituição sintática) é o único que a RFC 8259 exige: ele garante que a string é JSON válido. O escape Unicode (reescrever cada caractere como \uXXXX ou \u{XXXXX}) é uma escolha representacional, não um requisito sintático — apenas altera a aparência dos bytes no arquivo, não o que eles decodificam. Texto CJK já é válido em JSON como seus bytes UTF-8 brutos; o modo Unicode-escape da página o reescreve como \uXXXX, o que é útil ao inserir a string em um arquivo-fonte Java ou JavaScript onde o parser circundante teria que lidar com UTF-8 multibyte, mas isso adiciona 4-6 bytes por caractere e reduz a legibilidade. As regras de escape possuem casos extremos. O JSON.parse é estrito quanto a zeros à esquerda (01 é um erro de análise, mesmo que JavaScript o aceite como octal 1); o JSON.stringify no V8 sempre produz escapes mínimos necessários (caracteres de controle como \b/\n/\r/\t/\f quando possível, caso contrário como \uXXXX, e a barra /, U+2028, U+2029 são deixados crus para saída legível). Um surrogate solitário (um high surrogate não seguido por um low surrogate) é tecnicamente JSON válido conforme RFC 8259, mas o JSON.parse em modo estrito ou em TypeScript o rejeita como InvalidString; o modo de escape da página substitui surrogates solitários por \uFFFD (caractere de substituição) para que a saída seja convertida corretamente em qualquer parser padrão. Para incorporação em código-fonte JavaScript, a string JSON precisa de uma terceira camada de escape: JSON dentro de um literal de string JS deve escapar as próprias barras invertidas. O modo de saída JS string da página adiciona essa dupla codificação, e o botão eval ou JSON.parse mostra que as duas codificações decodificam para a mesma string. Contextos embutidos em HTML adicionam uma quarta camada: <, >, & precisam de escape de entidade HTML na página circundante, e valores de atributo também precisam de escape de aspas. JSON-em-HTML é perigoso (o problema do </script> mencionado acima) e deve ser evitado em favor de sinks seguros como atribuição textContent ou JSON.stringify dentro de um bloco <script type="application/json"> (lido posteriormente via script.textContent, nunca eval). JSON5 (um superconjunto popular) adiciona strings com aspas simples, strings multilinha, chaves sem aspas, vírgulas finais, NaN/Infinity e comentários de linha //. A página não produz saída JSON5; se precisar de conversão completa, use uma biblioteca dedicada.

  • Strings JSON (RFC 8259) devem escapar aspas duplas para barra-invertida-aspas, barra invertida para barra-dupla, e os 32 caracteres de controle U+0000..U+001F (\b \f \n \r \t, além do restante como \uXXXX). Tudo acima de U+001F é UTF-8 bruto válido, incluindo CJK, emoji e letras acentuadas.
  • Aparecem duas camadas de 'escape': o escape JSON (sintático, obrigatório) torna a string JSON válida; o escape Unicode (representacional) reescreve caracteres como \uXXXX e apenas altera a legibilidade, não a validade.
  • '/' opcional: / para \/ é permitido em JSON. Convenção: escapá-lo ao incorporar JSON em HTML <script> para que a sequência de fechamento da tag não feche a tag circundante.
  • CJK não é escapado em UTF-8 bruto JSON: o exemplo '你好' tem 6 bytes brutos. O modo Unicode-escape da página o reescreve como \u4f60\u597d para uso em arquivos-fonte, trocando legibilidade por compatibilidade.
  • Surrogates solitários: um high surrogate (U+D800..U+DBFF) não seguido por um low surrogate é tecnicamente JSON válido conforme RFC 8259, mas o JSON.parse em modo estrito ou TypeScript o rejeita. A página substitui surrogates solitários por \uFFFD para que a saída seja convertida corretamente em parsers estritos.
  • JSON.parse é estrito: zeros à esquerda (01) são um erro de análise, NaN/Infinity não são literais válidos, vírgulas finais não são permitidas. O JSON.stringify no V8 sempre produz escapes mínimos necessários e deixa a barra / e U+2028/U+2029 crus para legibilidade.
  • JSON-em-JS: para incorporar uma string JSON em um literal de string JS, dobre as barras invertidas. A saída 'JS string' da página adiciona essa camada; eval no resultado retorna a mesma string que JSON.parse.
  • Superconjunto JSON5: strings com aspas simples, strings multilinha, chaves sem aspas, vírgulas finais, NaN/Infinity, comentários de linha //. A página produz JSON estrito RFC 8259, não JSON5.

Exemplos

Strings com aspas duplas e barras invertidas

Entrada:  He said "Hello\World"
Saída: He said \"Hello\\World\"

Strings com quebras de linha e tabs

Entrada:  Line1\tIndent\nLine2
Saída: Line1\tIndent\nLine2

Strings com chinês e aspas duplas

Entrada:  {"name": "Alice", "msg": "He said \"Hi\""}
Saída: {\"name\": \"Alice\", \"msg\": \"He said \\\"Hi\\\"\"}

Perguntas frequentes

O que faz o escape de uma string JSON?

Ele coloca a entrada entre aspas e substitui cada caractere especial por sua sequência de escape segura para JSON: " → \", \ → \\, quebra de linha → \n, tab → \t, caracteres de controle → \u00NN. O resultado é um literal de string JSON válido que você pode colar em outro documento JSON ou em um editor de código.

Por que eu precisaria disso?

Casos comuns: incorporar uma mensagem multilinha dentro de um arquivo de configuração JSON, passar uma string JSON como argumento de linha de comando, colocar JSON dentro de JSON (por exemplo, um corpo de requisição de API que já é uma string codificada em JSON) ou sanitizar a entrada do usuário antes de registrá-la em log.

O escape de JSON é o mesmo que codificação de URL?

Não. O escape de JSON usa \n, \", \u00XX. A codificação de URL usa %20, %22, %0A. Contextos sintáticos diferentes, regras de escape diferentes. Use a que corresponder ao formato de destino.

O modo de unescape lida com todos os escapes JSON?

Sim — todos os escapes padrão (\", \\, \/, \b, \f, \n, \r, \t, \uXXXX). Pares substitutos para code points acima de U+FFFF (\uD83D\uDE00 = 😀) são remontados no emoji real. Sequências de escape malformadas geram um erro que você pode corrigir.

Qual a diferença entre dar escape em uma string e fazer stringify de um objeto?

O escape transforma um trecho de texto em uma string JSON entre aspas. O stringify (JSON.stringify) transforma um objeto JavaScript em um documento JSON completo. Esta página faz a primeira operação; para a segunda, escreva o objeto como JSON no seu editor de código ou use um formatador JSON.

Caracteres de controle sempre recebem escape?

Sim — o JSON exige isso. Quebras de linha, tabs, NULL e outros caracteres de controle ASCII (0x00-0x1F) precisam ter escape, ou a string resultante não será JSON válido. Algumas implementações também escapam DEL (0x7F) e caracteres acima de U+FFFF; a página segue estritamente a RFC 8259.

Os dados são enviados para algum lugar?

Não. O escape e o unescape rodam no seu navegador. O texto colado não é enviado para nenhum servidor.