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

Virgule finale en JSON : pourquoi { "a": 1, } lève une erreur

Une seule virgule en trop après le dernier élément d'un objet ou tableau JSON provoque une SyntaxError. Apprenez pourquoi JSON interdit les virgules finales, d'où elles viennent et comment les retirer.

Tu écris ce qui ressemble à du JSON parfaitement raisonnable —— chaque clé entre guillemets, chaque valeur valide —— et JSON.parse() jette toujours un SyntaxError. Le coupable est presque toujours une virgule finale : cette , supplémentaire qui traîne après le dernier item d'un objet ou d'un tableau. Voici pourquoi JSON l'interdit, par où elle se faufile, et comment t'en débarrasser.

Qu'est-ce qu'une virgule finale ?

Une virgule finale (aussi appelée « virgule pendante » ou « virgule terminale ») est une virgule qui apparaît après le dernier item d'une liste —— sans rien qui la suive avant le crochet fermant.

// Virgule finale dans un objet
{
  "name": "Ada",
  "score": 98,   // ← cette virgule n'a pas d'item suivant
}

// Virgule finale dans un tableau
[1, 2, 3,]
//       ^ même problème

Les deux exemples ci-dessus lanceront un SyntaxError quand on les passe à JSON.parse().

Pourquoi JSON interdit-il les virgules finales ?

La grammaire JSON (définie dans RFC 8259) spécifie qu'une virgule est un séparateur entre éléments —— elle doit toujours avoir une valeur des deux côtés. La règle formelle pour un objet JSON ressemble à ça :

object = "{" [ member *( "," member ) ] "}"
member = string ":" value

Une virgule doit être suivie d'un autre member. S'il n'y a rien après la virgule, la grammaire est invalide. C'était un choix de conception délibéré : JSON privilégie la simplicité et le parsing non ambigu sur le confort du développeur.

JavaScript a pris un chemin différent. ES5 (2009) a explicitement rendu légales les virgules finales dans les littéraux de tableau, et ES2017 a étendu ça aux paramètres de fonction. Les virgules finales en JS sont maintenant un style courant —— beaucoup de linters les imposent même parce qu'elles produisent des diffs git plus propres quand tu ajoutes un nouvel item à une liste.

L'écart entre ce que JavaScript autorise et ce que JSON autorise est la racine de presque toutes les erreurs de virgule finale que tu verras.

D'où viennent les virgules finales

Fichiers de config édités à la main

Les fichiers de config comme tsconfig.json, package.json, ou les paramètres d'app sont édités par des humains. Après avoir ajouté ou retiré une entrée, il est facile de laisser une virgule errante. Beaucoup d'éditeurs (VS Code, WebStorm) acceptent silencieusement JSONC (JSON-with-Comments) qui autorise les virgules finales, donc le fichier a l'air bien dans l'éditeur mais casse à l'exécution.

// Tu as supprimé "debug": true mais oublié de retirer la virgule
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2020",   // ← maintenant finale
  }
}

Sérialisation JavaScript → JSON

Les développeurs construisent parfois une chaîne JSON manuellement en interpolant des valeurs JavaScript, ou en utilisant Array.join(','). Si la logique ajoute une virgule après chaque item sans condition, le dernier item reçoit une virgule finale.

// ❌ sérialisation manuelle naïve
const parts = items.map(item => `"${item.name}": ${item.value}`);
const json = '{' + parts.join(',') + ',}'; // virgule en trop avant }

// ✅ utilise JSON.stringify —— produit toujours du JSON valide
const json = JSON.stringify(Object.fromEntries(items.map(i => [i.name, i.value])));

Sortie de LLM et IA

Les modèles de langage à qui on demande de « sortir du JSON » produisent fréquemment des virgules finales. Le modèle a vu d'énormes quantités de code JavaScript pendant l'entraînement où les virgules finales sont légales, donc il réplique le motif. Toujours valider ou réparer le JSON généré par IA avant de le parser.

Copier-coller depuis du source JavaScript

Copier un littéral d'objet d'un fichier .js ou .ts et le coller dans un contexte JSON est l'une des façons les plus courantes dont les virgules finales apparaissent. Le code source était du JavaScript valide ; la destination n'accepte que du JSON.

Comment trouver la virgule finale

Le message d'erreur t'oriente généralement près du problème, mais pas toujours exactement sur la virgule elle-même —— le parser ne remarque que quelque chose va mal quand il atteint le } ou ] inattendu :

SyntaxError: Expected double-quoted property name in JSON at position 58
// ou
SyntaxError: Unexpected token '}', ..."score": 98,}" is not valid JSON

Travaille en arrière depuis la position rapportée. La virgule finale est le caractère immédiatement avant le crochet fermant qui a déclenché l'erreur.

Pour les gros fichiers JSON, une recherche regex aide :

// Trouver les virgules finales dans les objets/tableaux
,\s*[}\]]

Comment le corriger

Option 1 —— La supprimer manuellement

Trouve le dernier item de l'objet ou tableau fautif et retire la virgule après. Pour les petits fichiers c'est l'approche la plus rapide.

Option 2 —— Remplacement regex (attention)

const fixed = raw.replace(/,\s*([}\]])/g, '$1');
JSON.parse(fixed);

Ça marche pour le cas courant, mais c'est fragile : ça peut corrompre des chaînes qui contiennent ,} ou ,] comme caractères littéraux. Utilise-le seulement quand tu sais que l'input ne contient pas de telles chaînes.

Option 3 —— Utiliser un vrai parser de réparation

Un parser de réparation comprend la grammaire JSON complète et retire les virgules finales seulement aux positions structurelles où elles sont invalides, sans toucher au contenu des chaînes. C'est l'approche la plus sûre pour du code de production ou de l'input non fiable.

Option 4 —— Passer à JSONC pour les fichiers de config

Si les virgules finales sont dans un fichier de config que tu contrôles, considère passer à un parser qui supporte JSONC (JSON with Comments). Le tsconfig.json de TypeScript utilise déjà JSONC. Pour les fichiers de config Node.js, des libs comme @humanwhocodes/momoa ou json5 parsent un sur-ensemble de JSON qui autorise virgules finales et commentaires.

Quand les virgules finales sont réellement autorisées : JSONC et JSON5

Deux formats adjacents à JSON autorisent délibérément les virgules finales (et quelques autres assouplissements), et valent la peine d'être reconnus :

  • JSONC (JSON avec commentaires) —— utilisé par tsconfig.json, le settings.json de VS Code, et beaucoup d'autres configs de développeur. JSONC autorise les commentaires // / /* */ et les virgules finales. Le fichier est toujours étiqueté .json, mais le JSON.parse() standard le rejette —— VS Code et le tooling embarquent des parsers conscients de JSONC.
  • JSON5 —— un sur-ensemble plus complet : commentaires, virgules finales, clés sans guillemets, apostrophes, chaînes multi-lignes, nombres hex. Opt-in avec le paquet npm json5 ou pyjson5 en Python. Utilise-le là où des humains éditent à la main et où tu contrôles le parser ; ne l'envoie pas via une API à des clients qui attendent du JSON strict.

Règle empirique : garde les virgules finales hors de tout ce qui traverse un parser JSON strict (réponses d'API, bodies de requête, fichiers consommés par des libs au hasard), et embrasse-les dans JSONC/JSON5 seulement là où le consommateur est au courant.

Prévenir les virgules finales

  • Ne construis jamais de chaînes JSON manuellement. Utilise JSON.stringify() —— il produit toujours une sortie conforme à la spec.
  • Ajoute une règle de linter. La règle jsonc/no-trailing-commas d'ESLint attrape les virgules finales dans les fichiers .json à la sauvegarde.
  • Valide la sortie d'IA. Lance toujours JSON.parse() (ou un parser de réparation) sur tout ce qu'un modèle de langage génère avant utilisation.
  • Utilise Prettier. Prettier reformate les fichiers JSON et retire les virgules finales automatiquement à la sauvegarde.

Foire aux questions

JSON autorise-t-il les virgules finales ?

Non. La grammaire JSON de RFC 8259 définit strictement une virgule comme un séparateur entre deux valeurs, donc une virgule sans rien après avant le } ou ] fermant est invalide. Chaque parser standard —— JSON.parse(), le module json de Python, encoding/json de Go —— la rejette.

Comment retirer une virgule finale du JSON ?

Pour un fichier, supprime la virgule après le dernier item manuellement. Pour des corrections répétées ou programmatiques, utilise JSON.stringify() pour régénérer le JSON, un parser de réparation, ou un outil comme JSON Fix qui retire les virgules finales structurelles sans toucher au contenu des chaînes.

Pourquoi JavaScript autorise les virgules finales mais pas JSON ?

JavaScript a ajouté les virgules finales en ES5 (tableaux) et ES2017 (paramètres de fonction) comme une feature de confort dev qui produit des diffs git plus propres. JSON est un format d'échange délibérément minimal qui privilégie le parsing non ambigu sur le confort, donc il ne les a jamais adoptées. Voir JSON vs objets JavaScript pour la liste complète des différences.

Quelle erreur provoque une virgule finale ?

Généralement SyntaxError: Unexpected token '}' ou Expected double-quoted property name in JSON, parce que le parser attend une autre valeur après la virgule et trouve à la place le crochet fermant. C'est une variante des plus larges erreurs JSON.parse « Unexpected token ».

Corrige-le maintenant —— aucune installation requise

Si tu as une chaîne JSON avec des virgules finales à corriger immédiatement, JSON Fix les retire automatiquement avec tout autre problème courant —— apostrophes, clés sans guillemets, littéraux Python, commentaires JavaScript. Colle ton JSON, clique Repair & Format, et recopie du JSON propre. Pas de compte, pas d'upload, aucune donnée ne quitte ton navigateur.