Come validare JSON online: guida per sviluppatori con esempi pratici

JSON (JavaScript Object Notation) e il formato di scambio dati piu utilizzato nello sviluppo web moderno. Praticamente tutte le API REST restituiscono dati in JSON, i file di configurazione come package.json o tsconfig.json usano questo formato, e database come MongoDB archiviano documenti in formato JSON.

Il problema e che un singolo carattere fuori posto (una virgola di troppo, un apice mancante, una parentesi non chiusa) rende l'intero JSON invalido e causa errori nella tua applicazione. Un JSON invalido in una risposta API puo rompere il frontend. Un tsconfig.json con un errore di sintassi impedisce a TypeScript di compilare.

Validare il JSON prima di usarlo evita ore di debug. Con il validatore JSON di NexTools, puoi incollare qualsiasi JSON, vedere gli errori con il numero di riga esatto e ottenere la formattazione automatica.

JSON ha regole di sintassi rigorose. Violarne una qualsiasi produce JSON invalido:

• Le chiavi devono essere tra virgolette doppie: {"nome": "Ana"} e valido. {nome: "Ana"} NON lo e.
• Le stringhe usano virgolette doppie, mai singole: "valore" e valido. 'valore' NON lo e.
• Non sono ammesse virgole finali: {"a": 1, "b": 2} e valido. {"a": 1, "b": 2,} NON lo e.
• Non sono ammessi commenti: Non puoi usare // ne /* */ nel JSON.
• I numeri non hanno virgolette: {"eta": 25} e valido. {"eta": "25"} funziona ma il valore e una stringa, non un numero.

Tipi di dati ammessi in JSON:

Tipo	Esempio	Note
String	"ciao mondo"	Sempre virgolette doppie
Number	42, 3.14, -7	Interi o decimali, senza virgolette
Boolean	true, false	Minuscolo, senza virgolette
Null	null	Minuscolo, senza virgolette
Array	[1, 2, 3]	Valori separati da virgole
Object	{"chiave": "valore"}	Coppie chiave-valore

Questi sono gli errori che incontrerai piu spesso lavorando con JSON:

1. Virgola dopo l'ultimo elemento:
   {"items": [1, 2, 3,]} — La virgola dopo il 3 e invalida.
2. Virgolette singole anziche doppie:
   {'nome': 'Marco'} — Deve essere {"nome": "Marco"}.
3. Chiavi senza virgolette:
   {eta: 30} — Deve essere {"eta": 30}.
4. Caratteri di controllo non escapati:
   Tab e ritorni a capo letterali nelle stringhe devono essere scritti come \t e \n.
5. Virgolette non escapate nelle stringhe:
   {"testo": "ha detto "ciao""} — Deve essere {"testo": "ha detto \"ciao\""}.
6. Commenti:
   JSON non supporta commenti di alcun tipo.
7. NaN, Infinity o undefined:
   Questi valori JavaScript NON sono validi in JSON. Usa null al loro posto.
8. Valori esadecimali:
   {"colore": 0xFF0000} non e valido. Usa {"colore": "#FF0000"}.
9. Tipi misti in array tipizzati:
   [1, "due", true] e JSON valido, ma molte API si aspettano array omogenei.
10. BOM (Byte Order Mark):
    Alcuni editor aggiungono byte invisibili all'inizio del file che invalidano il JSON. Salva sempre come UTF-8 senza BOM.

Tutti questi errori vengono rilevati automaticamente dal validatore JSON, che mostra la riga e la posizione esatta di ogni errore.

Il JSON puo essere presentato in due modi: formattato (pretty-print) per la lettura umana e minificato per la trasmissione efficiente.

JSON formattato:

{
  "utente": {
    "nome": "Maria",
    "eta": 28,
    "attivo": true
  }
}

JSON minificato (stessi dati, meno byte):

{"utente":{"nome":"Maria","eta":28,"attivo":true}}

La versione minificata occupa meno spazio (ideale per API e archiviazione), mentre quella formattata e molto piu facile da leggere e debuggare.

In JavaScript:

JSON.stringify(data, null, 2)  // formattato con 2 spazi
JSON.stringify(data)           // minificato

Per minificare file JSON grandi, usa il minificatore di codice che gestisce JSON, CSS e JavaScript.

Prima di JSON, XML era il formato dominante per lo scambio di dati. Entrambi sono ancora in uso, ma per scopi diversi:

Caratteristica	JSON	XML
Leggibilita	Piu conciso	Piu verboso
Dimensione	30-50% piu piccolo	Piu grande
Tipi di dati	String, number, boolean, null, array, object	Tutto e testo
Commenti	Non supportati	Supportati
Schema	JSON Schema	XSD, DTD
Uso principale	API REST, configurazione	SOAP, documenti, RSS
Parsing	JSON.parse() nativo	Richiede parser XML

Nel 2026, JSON domina nello sviluppo web, nelle API e nelle applicazioni mobile. XML rimane nei sistemi enterprise legacy, feed RSS/Atom e formati di documenti come DOCX.

Oltre alla validazione, questi strumenti complementari facilitano il lavoro:

• Validatore JSON: Controlla la sintassi, mostra errori con numero di riga e formatta automaticamente.
• Minificatore di codice: Comprime JSON rimuovendo spazi e ritorni a capo.
• Codificatore Base64: Codifica JSON in Base64 per trasmetterlo in URL o header HTTP.
• Comparatore di testo: Confronta due versioni di un JSON per trovare differenze.

Nel browser:

• JSON.parse(jsonString) — Converte una stringa JSON in un oggetto JavaScript. Lancia errore se il JSON e invalido.
• JSON.stringify(obj, null, 2) — Converte un oggetto in JSON formattato.

La validazione sintattica controlla solo che il JSON sia ben formato. Ma nelle applicazioni reali, devi anche verificare che i dati abbiano la struttura corretta.

Per questo esiste il JSON Schema, uno standard per descrivere la struttura dei documenti JSON:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["nome", "eta", "email"],
  "properties": {
    "nome": { "type": "string", "minLength": 1 },
    "eta": { "type": "integer", "minimum": 0, "maximum": 150 },
    "email": { "type": "string", "format": "email" }
  }
}

Con questo schema puoi validare automaticamente che ogni JSON utente abbia un nome (stringa non vuota), un'eta (intero tra 0 e 150) e un'email (formato valido). Librerie come Ajv (JavaScript), jsonschema (Python) e Newtonsoft (.NET) implementano la validazione JSON Schema.

Queste pratiche ti aiuteranno a evitare problemi comuni nei progetti reali:

• Valida sempre il JSON da fonti esterne: Qualsiasi JSON ricevuto da un'API, file caricato da un utente o webhook deve passare per JSON.parse() in un try-catch prima di essere elaborato.
• Usa camelCase per le chiavi: E la convenzione standard in JavaScript/TypeScript. userName invece di user_name.
• Evita piu di 3-4 livelli di annidamento: JSON profondamente annidato e difficile da leggere, attraversare e mantenere.
• Non salvare dati sensibili in JSON non crittografato: Token, password e chiavi private non devono mai apparire in JSON in chiaro nei log o nelle risposte API.
• Usa null invece di omettere campi opzionali: {"secondoNome": null} e meglio che omettere il campo.
• Gestisci gli errori di parsing con grazia: Non mostrare l'errore grezzo di JSON.parse all'utente finale. Registralo nei log e mostra un messaggio amichevole.