← Tutti gli articoli
Aggiornato il May 29, 202612 min read

Bad Escaped Character in JSON: cause, esempi e correzioni

Correggi gli errori "bad escaped character in JSON" da escape \x, percorsi Windows, stringhe regex, valori \u malformati e JSON con doppia codifica.

SyntaxError: Bad escaped character in JSON at position N significa che il parser ha trovato una barra rovesciata (\) dentro una stringa JSON, e il carattere successivo non era uno degli escape ammessi da JSON. Secondo la sezione 7 dell'RFC 8259, le stringhe JSON possono usare l'escape per virgolette doppie, barra rovesciata, barra normale, gli escape di controllo b, f, n, r, t, oppure un escape Unicode scritto come u seguito da esattamente quattro cifre esadecimali.

Nel debug reale, questo errore nasce quasi sempre da un valore copiato: un percorso Windows (C:\Users\Ada), un escape di JavaScript o della shell (\x1b), un pattern regex (\d+), un escape Unicode in stile Python (\U0001F600) o una stringa che è stata solo parzialmente de-escapata da un log. La soluzione non è "cancella le barre rovesciate". La soluzione è decidere quale deve essere il valore finale della stringa, e poi scrivere il testo JSON che rappresenta quel valore.

Questa guida usa la terminologia di JSON.parse() in JavaScript, ma la stessa regola vale per json.loads() di Python, encoding/json di Go, JSON.parse di Ruby, json_decode di PHP, jq, jsonb di Postgres e per la maggior parte dei parser JSON stretti.

Quale errore di stringa è questo?

La correzione in 30 secondi

  1. Vai alla position, line o column segnalata.
  2. Cerca una barra rovesciata un carattere prima.
  3. Controlla il carattere subito dopo la barra rovesciata.
  4. Se la barra rovesciata fa parte del dato, scrivila come \\.
  5. Se l'escape appartiene a un altro linguaggio (\x, \d, \U), traducilo nella sintassi JSON.
  6. Se la barra rovesciata è stata copiata da una riga di log tra virgolette, analizza un livello di parsing invece di rimuoverla con una regex.

Esempio:

{"path":"C:\Users\Ada\file.json"}
           ^
           U non è valido dopo una barra rovesciata JSON

Testo JSON corretto:

{
  "path": "C:\\Users\\Ada\\file.json"
}

Dopo il parsing, il valore effettivo dell'applicazione resta comunque:

C:\Users\Ada\file.json

Le barre rovesciate doppie esistono solo nel testo JSON.

Come appare l'errore

I vari motori usano formulazioni leggermente diverse:

// V8: Chrome, Node.js, Edge
SyntaxError: Bad escaped character in JSON at position 12

// Firefox
SyntaxError: JSON.parse: bad escaped character at line 1 column 13 of the JSON data

// Safari
SyntaxError: JSON Parse error: Invalid escape character \x

La position di V8 di solito indica il carattere successivo alla barra rovesciata, non la barra stessa. In questo JSON rotto, il carattere segnalato è la U in \Users:

{"path":"C:\Users\Ada\file.json"}
           ^^
           \U è l'escape errato

Quindi quando il messaggio dice position 12, ispeziona una piccola finestra prima e dopo la posizione 12. Il carattere errato è utile, ma è la barra rovesciata che lo precede a spiegare il bug.

Gli unici escape ammessi da JSON

Dentro una stringa JSON, una barra rovesciata può introdurre solo questi escape:

Escape JSON Carattere risultante Note
\" " Necessario per una virgoletta doppia dentro una stringa JSON
\\ \ Necessario per una barra rovesciata letterale
\/ / Opzionale; / è valido anche senza escape
\b Backspace U+0008
\f Form feed U+000C; è per questo che \file è pericoloso nei percorsi Windows
\n Line feed U+000A
\r Carriage return U+000D
\t Tabulazione U+0009
\uXXXX Code unit Unicode Esattamente quattro cifre esadecimali dopo u minuscolo

Tutto il resto è JSON non valido: \x, \', \d, \s, \w, \0, \v, \e, \U, \u{1F600}, \N{...}, \cA ed escape Unicode brevi come \u12.

Tabella delle correzioni rapide

Usa questa tabella quando sai già quale deve essere il valore finale.

Testo JSON rotto Perché fallisce Testo JSON valido
{ "path": "C:\Users\Ada\file.json" } \U e \A non sono validi; \f è valido ma diventa form feed, non un separatore di percorso. { "path": "C:\\Users\\Ada\\file.json" }
{ "path": "C:/Users/Ada/file.json" } Non fallisce. Le barre normali non richiedono escape. Mantienilo così se il consumatore accetta le barre normali.
{ "color": "\x1b[32mOK\x1b[0m" } JSON non ha l'escape \xNN. { "color": "\u001b[32mOK\u001b[0m" }
{ "name": "O\'Brien" } Gli apostrofi non richiedono escape nelle stringhe JSON. { "name": "O'Brien" }
{ "pattern": "^\d{4}-\d{2}-\d{2}$" } \d è un escape regex, non un escape JSON. { "pattern": "^\\d{4}-\\d{2}-\\d{2}$" }
{ "char": "\u12" } \u deve essere seguito da esattamente 4 cifre esadecimali. { "char": "\u0012" }
{ "emoji": "\u{1F600}" } JavaScript lo supporta nelle stringhe sorgente; JSON no. { "emoji": "😀" } oppure { "emoji": "\uD83D\uDE00" }

Un dettaglio scomodo merita un avviso a sé: \f è un escape JSON valido. Se un percorso Windows contiene \file, un parser può trasformarlo in un carattere form feed seguito da ile. Il parsing può riuscire mentre il valore del percorso è corrotto. È per questo che "riparare" ciecamente le stringhe di percorso è rischioso.

Causa 1: percorsi Windows copiati dentro JSON

I percorsi Windows sembrano innocui perché noi umani leggiamo la barra rovesciata come separatore di percorso:

{ "downloadDir": "C:\Users\Ada\Downloads" }

JSON legge la barra rovesciata come inizio di una sequenza di escape. Vede \U, poi si ferma perché la U maiuscola non è un escape JSON.

Scrivi barre rovesciate doppie in JSON:

{
  "downloadDir": "C:\\Users\\Ada\\Downloads"
}

Oppure usa le barre normali, se il programma ricevente le accetta:

{
  "downloadDir": "C:/Users/Ada/Downloads"
}

Per i file di configurazione, le barre normali fanno spesso commettere meno errori. Per valori esatti solo-Windows, le barre rovesciate doppie sono la rappresentazione JSON portabile.

Causa 2: mescolare stringhe sorgente JavaScript con testo JSON

Qui è dove molti esempi sul web confondono le persone senza volerlo. Ci sono due livelli:

  • Sintassi delle stringhe nel sorgente JavaScript
  • Sintassi del testo JSON dentro quella stringa JavaScript

Questo codice sorgente JavaScript è valido:

const raw = '{"path":"C:\\Users\\Ada"}';
JSON.parse(raw);

Ma il testo JSON che arriva al parser è:

{"path":"C:\\Users\\Ada"}

Se vuoi testare in JavaScript un campione JSON rotto senza che JavaScript stesso consumi prima le barre rovesciate, usa String.raw:

const broken = String.raw`{"path":"C:\Users\Ada"}`;
JSON.parse(broken);

Questo lancia Bad escaped character perché JSON.parse() riceve il vero testo JSON rotto.

Usa questo modello mentale leggendo gli stack trace: se il JSON arriva da un file .json, un body HTTP, un valore di localStorage o una stringa nel database, correggi il testo JSON. Se il JSON è dentro una stringa sorgente JavaScript, potresti aver bisogno di un livello di escape per JavaScript e di un altro livello per JSON.

Causa 3: prendere in prestito escape da altri linguaggi

JSON accetta \n e \t, ma non accetta molti escape che sono normali in altri linguaggi di programmazione:

{ "code": "\x1b[0m", "name": "O\'Brien" }

JSON valido:

{
  "code": "\u001b[0m",
  "name": "O'Brien"
}

Falsi amici comuni:

Escape Valido in Correzione JSON
\x1b JavaScript, Python, molte shell \u001b
\' Stringhe JavaScript/Python con singolo apice Usa ' senza barra rovesciata
\0 Abbreviazione NUL di JavaScript/Python \u0000
\v Tabulazione verticale di JavaScript \u000b
\U0001F600 Escape Unicode di Python Emoji UTF-8 letterale o coppia surrogata
\u{1F600} Escape di code point Unicode di JavaScript Emoji UTF-8 letterale o coppia surrogata

Se il produttore è il tuo codice, non tradurre a mano ogni caso. Costruisci un normale oggetto e lascia che il serializzatore JSON del linguaggio scriva JSON valido.

Causa 4: pattern regex memorizzati in configurazioni JSON

Le regex hanno il proprio linguaggio di escape. Le stringhe JSON hanno un linguaggio di escape separato. La barra rovesciata della regex deve sopravvivere al parsing JSON prima di raggiungere il motore regex.

Configurazione JSON rotta:

{ "datePattern": "^\d{4}-\d{2}-\d{2}$" }

Configurazione JSON valida:

{
  "datePattern": "^\\d{4}-\\d{2}-\\d{2}$"
}

Dopo il parsing JSON, l'applicazione vede questa stringa:

^\d{4}-\d{2}-\d{2}$

Solo dopo dovrebbe diventare un'espressione regolare:

const config = JSON.parse('{"datePattern":"^\\\\d{4}-\\\\d{2}-\\\\d{2}$"}');
const re = new RegExp(config.datePattern);

La stessa regola vale per \s, \w, \b, gruppi con nome, esempi di lookbehind e stringhe di sostituzione. Se la barra rovesciata è destinata a un parser successivo, raddoppiala in JSON.

Causa 5: escape Unicode malformati

L'escape Unicode di JSON ha larghezza fissa:

{ "char": "\u12" }

JSON valido:

{
  "char": "\u0012"
}

La u deve essere minuscola e seguita da esattamente quattro cifre esadecimali: 0-9, a-f o A-F.

Questi non sono escape Unicode JSON:

"\u{2028}"   // stile sorgente JavaScript, non JSON
"\U00002028" // stile Python, non JSON
"\u20G0"     // G non è una cifra esadecimale

I caratteri fuori dal Basic Multilingual Plane, come molte emoji e alcuni simboli matematici, possono essere memorizzati letteralmente in JSON UTF-8:

{
  "emoji": "😀"
}

Quando sono in forma di escape, sono rappresentati come coppia surrogata UTF-16:

{
  "emoji": "\uD83D\uDE00"
}

Evita i surrogati spaiati come \uD83D senza il corrispondente low surrogate. Alcuni parser li accettano come code unit, ma i sistemi a valle che richiedono Unicode ben formato potrebbero rifiutarli.

Causa 6: stringhe JSON costruite a mano

Questa è la versione in produzione del bug:

// Non sicuro: userInput può contenere barre rovesciate, virgolette o a-capo.
const payload = '{"message":"' + userInput + '"}';

Se userInput è C:\Users\Ada, il testo emesso è JSON non valido. Se contiene ", il JSON può rompersi in altro modo. Se contiene un a-capo grezzo, potresti ottenere invece un bad control character.

Usa un serializzatore:

const payload = JSON.stringify({
  message: userInput,
  path: 'C:\\Users\\Ada\\file.json',
  code: '\x1b[32mOK\x1b[0m',
});

JSON.stringify() gestisce l'escape specifico di JSON. Il risultato è testo JSON valido:

{
  "message": "...",
  "path": "C:\\Users\\Ada\\file.json",
  "code": "\u001b[32mOK\u001b[0m"
}

Lo stesso principio si applica in altri linguaggi:

import json

payload = json.dumps({
    "path": r"C:\Users\Ada\file.json",
    "pattern": r"^\d+$",
})

body, err := json.Marshal(map[string]string{
    "path": `C:\Users\Ada\file.json`,
    "pattern": `^\d+$`,
})

Se stai sistemando un produttore, questa è la vera correzione. Rattoppare JSON non valido a valle nasconde solo il punto in cui il testo errato è stato creato.

Come localizzare l'escape errato

Per JSON incollato, questo piccolo helper rende più facile vedere l'area attorno alla position di V8:

function showJsonParseContext(raw) {
  try {
    JSON.parse(raw);
    console.log('Valid JSON');
  } catch (error) {
    const message = String(error.message);
    const match = message.match(/position (\d+)/);

    if (!match) {
      console.log(message);
      return;
    }

    const pos = Number(match[1]);
    const start = Math.max(0, pos - 24);
    const end = Math.min(raw.length, pos + 24);
    const excerpt = raw.slice(start, end);

    console.log(message);
    console.log(JSON.stringify(excerpt));
    console.log(' '.repeat(pos - start) + '^');
  }
}

const raw = String.raw`{"path":"C:\Users\Ada\file.json"}`;
showJsonParseContext(raw);

JSON.stringify(excerpt) è intenzionale. Mostra le barre rovesciate e i caratteri di controllo come escape visibili, che è esattamente ciò di cui hai bisogno quando il bug è uno spazio bianco invisibile o un escape troppo aggressivo.

Per gli errori di Firefox in stile line e column, salta prima a quella riga, poi ispeziona il letterale di stringa sulla riga. Se la colonna esatta cade dopo una barra rovesciata, leggi anche il carattere precedente.

Strumento di riparazione o rifiutare il payload?

Usa uno strumento di riparazione quando:

  • Stai ripulendo uno snippet incollato.
  • Stai facendo il debug di una riga di log.
  • Stai revisionando l'output di un LLM.
  • Puoi confermare visivamente il valore riparato.
  • Il valore non guida movimenti di denaro, permessi, cancellazioni o cambi di stato irreversibili.

Rifiuta il payload e correggi il produttore quando:

  • Il JSON arriva da un contratto di API.
  • Il valore influenza fatturazione, permessi, sicurezza o cancellazione dei dati.
  • Il parser ha dovuto tirare a indovinare fra più significati possibili.
  • Un percorso, una regex o una sequenza di escape potrebbero essere validi ma semanticamente sbagliati.

Ad esempio, riparare C:\Users\Ada\file.json non è solo un'operazione sintattica. \f in \file è un escape valido, quindi uno strumento può interpretarlo come carattere form feed invece di preservare la barra rovesciata. Un umano o il codice del produttore deve decidere il percorso previsto.

Lo strumento JSON Fix su questo sito si usa al meglio come assistente di debug locale nel browser: incolla il testo, ispeziona l'output, poi valida il JSON riparato. Non dovrebbe essere il livello di ingestione silenzioso per payload di produzione malformati.

Come de-escapare JSON in modo sicuro

A volte le barre rovesciate non sono errate; il JSON è a doppia codifica. Potresti vederlo nei log:

{\"name\":\"Ada\",\"path\":\"C:\\\\Users\\\\Ada\"}

Non eseguire un replace(/\\/g, '') a tappeto. Distrugge gli escape reali.

Analizza un livello di JSON valido alla volta:

// Il valore esterno è una stringa JSON che contiene testo JSON.
const wrapped = '"{\\"name\\":\\"Ada\\",\\"path\\":\\"C:\\\\\\\\Users\\\\\\\\Ada\\"}"';

const once = JSON.parse(wrapped);
// once è: {"name":"Ada","path":"C:\\Users\\Ada"}

const data = JSON.parse(once);
// data è: { name: "Ada", path: "C:\\Users\\Ada" }

Se il primo parse fallisce con Bad escaped character, l'input non è semplicemente codificato. È testo JSON non valido e serve una riparazione mirata.

Checklist di prevenzione

  • Non concatenare mai stringhe dell'utente dentro JSON.
  • Usa JSON.stringify(), json.dumps(), json.Marshal() o il serializzatore JSON della tua piattaforma.
  • Salva i pattern regex in JSON con barre rovesciate doppie.
  • Preferisci le barre normali per i percorsi quando il consumatore le accetta.
  • Metti fra virgolette e testa gli esempi copiati da log, shell e documentazione.
  • Valida i file .json generati in CI con un vero parser.
  • Logga un'anteprima sicura attorno alla posizione del parser invece di loggare l'intero payload.
  • Tratta la riparazione automatica come un flusso di lavoro per sviluppatori, non come un contratto di produzione.

Domande frequenti

Cosa significa "Bad escaped character in JSON"?

Una barra rovesciata dentro una stringa JSON è seguita da un carattere che JSON non permette dopo \. Gli escape validi sono ", \, /, b, f, n, r, t e uXXXX.

Come correggo un percorso Windows in JSON?

Scrivi ogni barra rovesciata del percorso come \\, ad esempio C:\\Users\\Ada\\file.json. Se il programma ricevente accetta le barre normali, C:/Users/Ada/file.json è JSON valido e più leggibile.

Perché la mia regex funziona in JavaScript ma fallisce in JSON?

Il parser JSON vede la stringa prima del motore regex. Un escape regex come \d va scritto come \\d in JSON, così la stringa risultante dal parsing contiene ancora \d.

\x1b è JSON valido?

No. \xNN è comune in JavaScript, Python e negli esempi shell, ma JSON non lo supporta. Usa \u001b per il carattere ESC ANSI, o rimuovi i codici colore ANSI prima di serializzare i log.

È la stessa cosa di "Bad control character"?

No. "Bad escaped character" significa che il carattere dopo una barra rovesciata non è valido. "Bad control character" significa che un byte di controllo grezzo, come un a-capo letterale, una tabulazione, un NUL o un byte ESC, compare dentro una stringa JSON.

Gli strumenti di riparazione JSON possono correggere automaticamente gli escape errati?

A volte, per snippet incollati in cui il valore previsto è ovvio. Non riparare automaticamente e in modo silenzioso payload di API, dati sensibili per la sicurezza, pagamenti, permessi, cancellazioni, o valori dove \f, \n o \t potrebbero essere validi ma non intenzionali.

Come de-escapo JSON?

Analizza un livello alla volta con JSON.parse(). Un valore a doppia codifica diventa una normale stringa JSON dopo il primo parse e un vero oggetto o array dopo il secondo. Evita di rimuovere le barre rovesciate con regex perché corrompe gli escape validi.

Come prevengo questo errore nel codice sorgente?

Costruisci valori nativi e serializzali con JSON.stringify() o il serializzatore equivalente nel tuo linguaggio. Non assemblare JSON con concatenazioni di stringhe.

Correggi ora

Fonti

Ultima revisione: luglio 2026.