← Tous les articles
Mis à jour le May 29, 20265 min read

Unexpected Token u en JSON à la position 0 : parser undefined

L'erreur « Unexpected token u » signifie que vous avez appelé JSON.parse(undefined). Apprenez pourquoi undefined devient "undefined", comment vous en prémunir et un helper de parsing sûr.

SyntaxError: Unexpected token 'u', "undefined" is not valid JSON (moteurs anciens : Unexpected token u in JSON at position 0) signifie presque toujours que tu as appelé JSON.parse(undefined). JavaScript stringifie undefined en texte "undefined", et le parser s'étrangle sur le u de tête. Voici pourquoi et comment corriger.

À quoi ressemble l'erreur

// 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 plus ancien

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

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

Le u en position 0 est la première lettre de la chaîne "undefined" —— le parser n'a jamais reçu de vraies données.

Pourquoi ça arrive : tu as parsé undefined

JSON.parse() coercie d'abord son argument en chaîne. Passe undefined et il parse le texte littéral "undefined", qui n'est pas du JSON valide. La valeur vaut généralement undefined parce que :

  • Une variable ou un argument de fonction n'a jamais été assigné
  • Une propriété d'objet n'existe pas (typo ou mauvaise forme) : obj.missing
  • Une valeur async n'est pas encore prête (parsée avant await)
  • Une fonction sans return utilisée comme source

Exemple cassé

const cached = localStorage.getItem('settings'); // clé absente → null, OK
const draft  = window.appState?.draft;            // propriété absente → undefined
const data   = JSON.parse(draft);                 // ❌ "undefined" is not valid JSON

Exemple corrigé

// Guard avant de parser
const data = draft ? JSON.parse(draft) : null;

// Ou un helper sûr
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);

Note : JSON.parse(null) ne jette pas —— il renvoie null —— et localStorage.getItem() renvoie null (pas undefined) pour une clé manquante. Donc une erreur u pointe spécifiquement vers une valeur undefined, pas une clé de storage manquante.

SyntaxError vs TypeError : pourquoi tu obtiens celui-ci

Détail subtil mais utile : JSON.parse(undefined) jette une SyntaxError, pas une TypeError. Pourquoi ? Parce que la spec dit que JSON.parse d'abord coercie son argument en chaîne ("undefined") et parse ensuite cette chaîne. L'erreur est « cette chaîne n'est pas du JSON valide », pas « tu as passé le mauvais type ». C'est pour ça que JSON.parse(undefined) et JSON.parse("undefined") produisent le même message en position 0.

Contraste avec les APIs qui font de la vérification de type, comme JSON.stringify(BigInt(1)) → TypeError, ou JSON.parse(Symbol()) → TypeError (les Symbols ne peuvent être coerciés en chaîne). Si tu attrapes des erreurs de parsing, restreins sur err instanceof SyntaxError pour gérer les mauvaises données séparément des mauvais arguments.

Comment le corriger —— étape par étape

  1. Log l'entrée :console.log(typeof src, src) juste avant le parse. Si ça affiche undefined, c'est le coupable.
  2. Trace où elle devrait être assignée —— un champ d'état non initialisé, un argument manquant, ou une propriété qui n'existe pas sur l'objet.
  3. Ajoute un guard (if (src)) ou un fallback safeParse pour qu'une valeur absente n'arrive pas à JSON.parse().
  4. Si c'est async, assure-toi de faire await sur la valeur avant le parsing.

Foire aux questions

Que signifie « Unexpected token u in JSON at position 0 » ?

Tu as passé undefined à JSON.parse(). Ça devient la chaîne "undefined", et le u de tête n'est pas un caractère de début JSON valide.

Est-ce la même chose que l'erreur « token o » ou « token < » ?

Même famille, valeur différente. u = undefined ; token o = un objet stringifié en [object Object] ; token < = une réponse HTML. Le caractère nommé te dit ce qui a vraiment été passé.

Pourquoi JSON.parse(null) ne jette-t-il pas la même erreur ?

"null" est du JSON valide, donc JSON.parse(null) renvoie null. Seul undefined (→ "undefined") déclenche l'erreur u.

Corrige-le maintenant