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

Unexpected Token u in JSON alla posizione 0: parsing di undefined

L'errore «Unexpected token u» significa che hai chiamato JSON.parse(undefined). Scopri perché undefined diventa "undefined", come proteggerti e un helper di parsing sicuro.

SyntaxError: Unexpected token 'u', "undefined" is not valid JSON (engine più vecchi: Unexpected token u in JSON at position 0) significa quasi sempre che hai chiamato JSON.parse(undefined). JavaScript stringifica undefined nel testo "undefined", e il parser si blocca sulla u iniziale. Ecco perché e come correggere.

Come appare l'errore

// V8 (Chrome / Node / Edge)
SyntaxError: "undefined" is not valid JSON
SyntaxError: Unexpected token 'u', "undefined" is not valid JSON
SyntaxError: Unexpected token u in JSON at position 0   // V8 più vecchio

// Firefox
SyntaxError: JSON.parse: unexpected character at line 1 column 1

// Safari
SyntaxError: JSON Parse error: Unexpected identifier "undefined"

La u in posizione 0 è la prima lettera della stringa "undefined" —— il parser non ha mai ricevuto dati reali.

Perché succede: hai parsato undefined

JSON.parse() forza prima il suo argomento a stringa. Passa undefined e parsa il testo letterale "undefined", che non è JSON valido. Il valore è di solito undefined perché:

  • Una variabile o un argomento di funzione non è mai stato assegnato
  • Una proprietà di un oggetto non esiste (typo o shape sbagliato): obj.missing
  • Un valore async non è ancora pronto (parsato prima dell'await)
  • Una funzione senza return usata come sorgente

Esempio rotto

const cached = localStorage.getItem('settings'); // key mancante → null, OK
const draft  = window.appState?.draft;            // proprietà mancante → undefined
const data   = JSON.parse(draft);                 // ❌ "undefined" is not valid JSON

Esempio corretto

// Guard prima di parsare
const data = draft ? JSON.parse(draft) : null;

// Oppure un helper sicuro
function safeParse(text, fallback = null) {
  if (typeof text !== 'string' || text.trim() === '') return fallback;
  try { return JSON.parse(text); } catch { return fallback; }
}
const data2 = safeParse(draft);

Nota: JSON.parse(null) non lancia —— restituisce null —— e localStorage.getItem() restituisce null (non undefined) per una key mancante. Quindi un errore u punta in modo specifico a un valore undefined, non a una key di storage mancante.

SyntaxError vs TypeError: perché ottieni questo

Dettaglio sottile ma utile: JSON.parse(undefined) lancia un SyntaxError, non un TypeError. Perché? Perché la spec dice che JSON.parse prima forza l'argomento a stringa ("undefined") e poi parsa quella stringa. L'errore è «questa stringa non è JSON valido», non «hai passato il tipo sbagliato». Ecco perché JSON.parse(undefined) e JSON.parse("undefined") producono lo stesso messaggio di posizione 0.

Contrasta con API che davvero fanno type-check, come JSON.stringify(BigInt(1)) → TypeError, o JSON.parse(Symbol()) → TypeError (i Symbol non possono essere forzati a stringa). Se catturi errori di parsing, restringi con err instanceof SyntaxError per gestire dati cattivi separatamente da argomenti cattivi.

Come risolvere —— passo dopo passo

  1. Logga l'input:console.log(typeof src, src) subito prima del parse. Se stampa undefined, è quello il colpevole.
  2. Risali a dove dovrebbe essere impostato —— un campo di state non inizializzato, un argomento mancante, o una proprietà che non esiste sull'oggetto.
  3. Aggiungi un guard (if (src)) o un fallback safeParse così un valore assente non arriva a JSON.parse().
  4. Se è async, assicurati di fare await sul valore prima di parsare.

Domande frequenti

Cosa significa «Unexpected token u in JSON at position 0»?

Hai passato undefined a JSON.parse(). Diventa la stringa "undefined", e la u iniziale non è un carattere di inizio JSON valido.

È la stessa cosa degli errori «token o» o «token <»?

Stessa famiglia, valore diverso. u = undefined; token o = un oggetto stringificato in [object Object]; token < = una risposta HTML. Il carattere nominato ti dice cosa è stato davvero passato.

Perché JSON.parse(null) non lancia lo stesso errore?

"null" è JSON valido, quindi JSON.parse(null) restituisce null. Solo undefined (→ "undefined") fa scattare l'errore u.

Risolvi subito