Come formattare e validare il JSON

Per formattare il JSON, incollalo in un formattatore che aggiunge indentazione e a capo, così che la struttura sia facile da leggere; per validarlo, fallo passare attraverso un parser che ne controlla la sintassi e indica il punto esatto in cui si rompe. Formattazione (chiamata anche abbellimento o pretty-printing) e validazione di solito avvengono insieme: un buon strumento re-indenta il JSON valido e, quando l’input è rotto, ti dice con precisione cosa non va. Di seguito trovi cosa fa davvero ciascuna azione, quando formattare e quando minificare, e come leggere e correggere gli errori che il parser segnala.

Formattare, minificare, validare: tre lavori diversi

Queste tre parole vengono usate come sinonimi, ma fanno cose distinte ai tuoi dati.

• La formattazione (abbellimento) aggiunge indentazione e a capo, così che oggetti e array annidati si allineino visivamente. Non cambia i dati, solo gli spazi bianchi, rendendo molto più facile scorrere con l’occhio un file di configurazione o una risposta di un’API.
• La minificazione fa l’opposto: rimuove ogni spazio, tabulazione e a capo non essenziale, in modo che il payload sia il più piccolo possibile. I dati sono identici, solo compattati di fatto su un’unica riga.
• La validazione verifica se il testo è JSON valido. Un validatore analizza l’input e conferma che è ben formato oppure segnala il primo errore di sintassi che incontra.

In pratica, formatti mentre leggi ed esegui il debug, e minifichi appena prima di inviare i dati in rete o memorizzarli. La validazione sta alla base di entrambe: non puoi formattare o minificare in modo affidabile un testo che non è JSON valido in partenza.

Quando formattare e quando minificare

Ricorri alla formattazione ogni volta che una persona deve guardare i dati:

• Ispezionare la risposta di un’API durante il debug.
• Rivedere o modificare un package.json, un tsconfig.json o qualsiasi file di configurazione.
• Confrontare due file JSON nel controllo di versione, dove un’indentazione coerente mantiene la differenza piccola e significativa.
• Incollare un blocco denso su una sola riga preso da un log, volendo capirne davvero la struttura.

Ricorri alla minificazione quando contano i byte e nessuno deve leggere:

• Spedire JSON nel corpo di una risposta o richiesta HTTP, dove payload più piccoli significano trasferimenti più veloci.
• Incorporare la configurazione in una variabile d’ambiente o in un URL.
• Memorizzare molti record, dove gli spazi bianchi si sommano su migliaia di righe.

Un’abitudine utile: tieni i file sorgente formattati per la leggibilità, e lascia che la build o il server minifichino in uscita. Ottieni il meglio di entrambi: leggibili nel repository, compatti in rete.

Gli errori JSON più comuni (e come correggerli)

Il JSON è volutamente rigido, ed è proprio questo a renderlo portabile in ogni linguaggio. La stessa rigidità manda in confusione le persone, soprattutto chi è abituato a scrivere object literal in JavaScript. Questi sono gli errori che ricorrono di continuo:

• Virgole finali. Una virgola dopo l’ultimo elemento di un oggetto o di un array — {"a": 1,} — non è valida. Rimuovila. È in assoluto l’errore più comune, perché la maggior parte dei linguaggi di programmazione la consente.
• Apici singoli al posto degli apici doppi. Il JSON richiede gli apici doppi sia per le chiavi sia per i valori stringa. {'name': 'Ada'} deve diventare {"name": "Ada"}.
• Chiavi senza apici. Le chiavi sono sempre stringhe tra apici. {name: "Ada"} è un oggetto JavaScript, non JSON; deve essere {"name": "Ada"}.
• Virgole mancanti. Ogni elemento tranne l’ultimo ha bisogno di una virgola che lo separi dal successivo. Due valori di fila senza nulla in mezzo non verranno analizzati.
• Commenti. Il JSON non ha sintassi per i commenti. Le righe che iniziano con // o racchiuse in /* */ non sono ammesse e vanno rimosse prima che il testo venga validato.

Qualche altra cosa a cui fare attenzione: i numeri non possono avere zeri iniziali né un punto decimale finale, le stringhe devono fare l’escape dei caratteri speciali come \n e \", e gli unici letterali ammessi oltre a numeri e stringhe sono true, false e null (in minuscolo, senza apici).

Come leggere un errore del parser

Quando la validazione fallisce, il parser di solito segnala una posizione: una riga e una colonna, oppure un offset di carattere. Leggi quella posizione alla lettera: l’errore viene segnalato al primo carattere a cui il parser non è riuscito a dare un senso, che spesso è subito dopo l’errore reale. Per esempio, una virgola mancante viene spesso segnalata all’inizio della chiave successiva, non nello spazio in cui la virgola sarebbe dovuta stare. Vai al punto indicato, poi guarda il token immediatamente prima. Una volta corretto il primo errore, valida di nuovo, perché il parser si ferma al primo problema e potrebbero essercene altri più avanti.

Fallo in privato, nel tuo browser

Molti strumenti JSON online inviano a un server remoto qualunque cosa tu incolli per elaborarla. Con il JSON questi sono spesso i dati peggiori da caricare, perché è proprio lì che tendono ad annidarsi chiavi API, token di accesso, hostname interni, dati dei clienti e altri segreti.

Il Formattatore JSON di Andev evita tutto questo. Usa i JSON.parse e JSON.stringify nativi del browser, il che significa:

• I tuoi dati non vengono mai caricati. Tutto gira in locale sul tuo dispositivo; niente viene inviato da nessuna parte.
• Mostra l’errore di parsing esatto. Quando l’input non è valido, vedi il messaggio specifico e la posizione, così puoi andare dritto al problema.
• Scegli tu la dimensione dell’indentazione. Formatta con due spazi, quattro spazi o tabulazioni per adattarti allo stile del tuo progetto, oppure minifica su un’unica riga.
• È istantaneo. Nessun viaggio di andata e ritorno con attesa; il risultato compare alla stessa velocità con cui incolli.

Poiché si appoggia allo stesso motore JSON che le tue applicazioni già usano, la validazione che riporta corrisponde a come si comporterà davvero il tuo codice quando analizzerà la stessa stringa. Questo lo rende sicuro da usare con configurazioni e payload API sensibili, e affidabile come rapido controllo di verifica prima del rilascio.

Per attività affini, lo stesso approccio locale e senza caricamenti alimenta il codificatore e decodificatore Base64 di Andev e il suo codificatore e decodificatore di URL, entrambi comodi quando il JSON viene incorporato in un data URI, in un token o in una stringa di query.

Punti chiave

• La formattazione aggiunge indentazione per la leggibilità; la minificazione rimuove gli spazi bianchi per payload più piccoli; la validazione controlla la sintassi. Sono tre lavori distinti.
• Formatta per le persone, minifica per la rete: tieni i file sorgente leggibili e lascia che la build compatti l’output.
• La maggior parte degli errori sono trappole della rigidità: virgole finali, apici singoli, chiavi senza apici, virgole mancanti e commenti sono tutti JSON non valido.
• Leggi gli errori del parser nella posizione segnalata, poi controlla il token subito prima; correggi un errore e valida di nuovo, dato che il parser si ferma al primo.
• Tieni tutto in locale. Un formattatore nativo del browser non carica mai i tuoi dati, cosa che conta soprattutto per i segreti che vivono dentro la configurazione e il JSON delle API.

Devi ripulire o controllare del JSON proprio adesso? Apri il Formattatore JSON gratuito e privato, senza caricamenti, senza registrazione, oppure sfoglia l’intera raccolta di strumenti per sviluppatori nel browser.