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

Virgola finale in JSON: perché { "a": 1, } lancia un errore

Una singola virgola di troppo dopo l'ultimo elemento di un oggetto o array JSON causa un SyntaxError. Impara perché JSON vieta le virgole finali, da dove vengono e come rimuoverle.

Scrivi quello che sembra JSON perfettamente ragionevole —— ogni chiave tra virgolette, ogni valore valido —— eppure JSON.parse() lancia comunque un SyntaxError. Il colpevole è quasi sempre una virgola finale: quella , in più rimasta dopo l'ultimo item di un oggetto o array. Ecco perché JSON la vieta, da dove si infila e come liberartene.

Cos'è una virgola finale?

Una virgola finale (chiamata anche «dangling comma» o «virgola terminale») è una virgola che appare dopo l'ultimo item di una lista —— senza nulla dopo prima della parentesi di chiusura.

// Virgola finale in un oggetto
{
  "name": "Ada",
  "score": 98,   // ← questa virgola non ha item successivo
}

// Virgola finale in un array
[1, 2, 3,]
//       ^ stesso problema

Entrambi gli esempi sopra lanciano un SyntaxError quando passati a JSON.parse().

Perché JSON vieta le virgole finali?

La grammatica JSON (definita in RFC 8259) specifica che la virgola è un separatore tra elementi —— deve sempre avere un valore su entrambi i lati. La regola formale per un oggetto JSON è questa:

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

Una virgola deve essere seguita da un altro member. Se non c'è niente dopo la virgola, la grammatica è invalida. Era una scelta di design deliberata: JSON dà priorità a semplicità e parsing senza ambiguità rispetto alla comodità per lo sviluppatore.

JavaScript ha preso un'altra strada. ES5 (2009) ha esplicitamente reso legali le virgole finali nei letterali di array, ed ES2017 ha esteso ai parametri di funzione. Le virgole finali in JS ora sono stile comune —— molti linter le impongono pure perché producono diff git più puliti quando aggiungi un nuovo item a una lista.

Il divario tra ciò che JavaScript consente e ciò che JSON consente è la radice di quasi ogni errore di virgola finale che vedrai mai.

Da dove vengono le virgole finali

File di config modificati a mano

File di config come tsconfig.json, package.json, o impostazioni di app sono modificati da umani. Dopo aver aggiunto o rimosso una voce, è facile lasciare una virgola vagante. Molti editor (VS Code, WebStorm) accettano silenziosamente JSONC (JSON-with-Comments) che ammette virgole finali, quindi il file sembra a posto nell'editor ma si rompe a runtime.

// Hai cancellato "debug": true ma dimenticato di togliere la virgola
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2020",   // ← ora è finale
  }
}

Serializzazione JavaScript → JSON

A volte gli sviluppatori costruiscono una stringa JSON manualmente con interpolazione di valori JavaScript, o usando Array.join(','). Se la logica aggiunge una virgola dopo ogni item incondizionatamente, l'ultimo item si ritrova con una virgola finale.

// ❌ serializzazione manuale ingenua
const parts = items.map(item => `"${item.name}": ${item.value}`);
const json = '{' + parts.join(',') + ',}'; // virgola in più prima di }

// ✅ usa JSON.stringify —— produce sempre JSON valido
const json = JSON.stringify(Object.fromEntries(items.map(i => [i.name, i.value])));

Output LLM e AI

I modelli linguistici a cui si chiede di «produrre JSON» frequentemente generano virgole finali. Il modello ha visto enormi quantità di codice JavaScript durante l'allenamento dove le virgole finali sono legali, quindi replica il pattern. Valida o ripara sempre il JSON generato da AI prima di parsarlo.

Copia-incolla da sorgenti JavaScript

Copiare un letterale di oggetto da un file .js o .ts e incollarlo in un contesto JSON è uno dei modi più comuni in cui appaiono le virgole finali. Il codice sorgente era JavaScript valido; la destinazione accetta solo JSON.

Come trovare la virgola finale

Il messaggio di errore di solito ti indirizza vicino al problema, ma non sempre esattamente alla virgola stessa —— il parser nota che qualcosa non va solo quando incontra l'inaspettata } o ]:

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

Lavora a ritroso dalla posizione segnalata. La virgola finale è il carattere immediatamente prima della parentesi di chiusura che ha innescato l'errore.

Per file JSON grandi, una ricerca regex aiuta:

// Trovare virgole finali in oggetti/array
,\s*[}\]]

Come risolverlo

Opzione 1 —— Cancellarla manualmente

Trova l'ultimo item nell'oggetto o array incriminato e rimuovi la virgola dopo. Per file piccoli è l'approccio più rapido.

Opzione 2 —— Sostituzione regex (attenzione)

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

Funziona per il caso comune ma è fragile: può corrompere stringhe che contengono ,} o ,] come caratteri letterali. Usalo solo quando sai che l'input non contiene tali stringhe.

Opzione 3 —— Usare un parser di riparazione vero

Un parser di riparazione capisce la grammatica JSON completa e rimuove le virgole finali solo nelle posizioni strutturali in cui sono invalide, senza toccare il contenuto delle stringhe. È l'approccio più sicuro per codice di produzione o input non fidato.

Opzione 4 —— Passare a JSONC per i file di config

Se le virgole finali sono in un file di config che controlli, considera il passaggio a un parser che supporti JSONC (JSON con commenti). Il tsconfig.json di TypeScript già usa JSONC. Per file di config Node.js, librerie come @humanwhocodes/momoa o json5 parsano un superset di JSON che consente virgole finali e commenti.

Quando le virgole finali sono effettivamente consentite: JSONC e JSON5

Due formati vicini al JSON consentono deliberatamente le virgole finali (e qualche altro allentamento) e vale la pena riconoscerli:

  • JSONC (JSON con commenti) —— usato da tsconfig.json, il settings.json di VS Code, e molti altri config per sviluppatori. JSONC consente i commenti // / /* */ e le virgole finali. Il file è ancora etichettato .json, ma il JSON.parse() standard lo rifiuta —— VS Code e il tooling spediscono parser consapevoli di JSONC.
  • JSON5 —— un superset più completo: commenti, virgole finali, key senza virgolette, virgolette singole, stringhe multi-riga, numeri esadecimali. Opt-in col pacchetto npm json5 o pyjson5 in Python. Usalo dove gli umani modificano a mano i dati e controlli il parser; non spedirlo via API a client che si aspettano JSON stretto.

Regola pratica: tieni le virgole finali fuori da tutto ciò che attraversa un parser JSON stretto (risposte API, request body, file consumati da librerie casuali), e abbracciale dentro JSONC/JSON5 solo dove il consumatore lo sa.

Prevenire le virgole finali

  • Non costruire mai stringhe JSON a mano. Usa JSON.stringify() —— produce sempre output conforme alla spec.
  • Aggiungi una regola del linter. La regola jsonc/no-trailing-commas di ESLint cattura le virgole finali nei file .json al salvataggio.
  • Valida l'output AI. Esegui sempre JSON.parse() (o un parser di riparazione) su qualsiasi cosa generata da un modello linguistico prima di usarla.
  • Usa Prettier. Prettier riformatta i file JSON e rimuove le virgole finali automaticamente al salvataggio.

Domande frequenti

JSON consente le virgole finali?

No. La grammatica JSON in RFC 8259 definisce la virgola strettamente come separatore tra due valori, quindi una virgola senza nulla dopo prima della } o ] di chiusura è invalida. Ogni parser standard —— JSON.parse(), il modulo json di Python, encoding/json di Go —— la rifiuta.

Come rimuovo una virgola finale dal JSON?

Per un file, cancella la virgola dopo l'ultimo item a mano. Per fix ripetuti o programmatici, usa JSON.stringify() per rigenerare il JSON, un parser di riparazione, o uno strumento come JSON Fix che rimuove le virgole finali strutturali senza toccare il contenuto delle stringhe.

Perché JavaScript consente le virgole finali ma JSON no?

JavaScript ha aggiunto le virgole finali in ES5 (array) ed ES2017 (parametri di funzione) come feature di comodità per gli sviluppatori che produce diff git più puliti. JSON è un formato di scambio deliberatamente minimale che dà priorità al parsing senza ambiguità rispetto alla comodità, quindi non le ha mai adottate. Vedi JSON vs oggetti JavaScript per l'elenco completo delle differenze.

Che errore causa una virgola finale?

Di solito SyntaxError: Unexpected token '}' o Expected double-quoted property name in JSON, perché il parser si aspetta un altro valore dopo la virgola e trova invece la parentesi di chiusura. Questa è una variante dei più ampi errori «Unexpected token» di JSON.parse.

Risolvi subito —— nessuna installazione richiesta

Se hai una stringa JSON con virgole finali da sistemare subito, JSON Fix le rimuove automaticamente insieme a qualsiasi altro problema comune —— virgolette singole, key senza virgolette, letterali Python, commenti JavaScript. Incolla il tuo JSON, clicca Repair & Format, e ricopia JSON pulito. Nessun account, nessun upload, nessun dato lascia il tuo browser.