calcolatrice online

Incolla JSON compatto, minimizzato o disordinato e ottieni immediatamente un output perfettamente indentato. Il formattatore analizza il tuo JSON con la funzione nativa del browser JSON.parse (secondo ECMA-404), preserva i caratteri Unicode e lo riemette con l'indentazione scelta:

• 2 spazi (predefinito per npm e prettier)
• 4 spazi
• tab

Oggetti e array annidati vengono indentati correttamente a qualsiasi livello di profondità. Chiavi, stringhe, numeri, booleani e null ricevono colori di evidenziazione della sintassi distinti per consentirti di analizzare la struttura a colpo d'occhio.

L'etichetta 'beautifier' è intercambiabile con 'formatter' o 'pretty printer' — descrivono tutti la stessa operazione: produrre JSON leggibile dall'uomo a partire da un input compatto.

La validazione viene eseguita mentre scrivi. Se il tuo JSON non viene analizzato correttamente, il formattatore mostra l'esatta riga, colonna e ciò che il parser si aspettava.

La validazione è rigorosa secondo la RFC 8259 (lo standard Internet IETF) e ECMA-404 — nessun commento, nessuna virgola finale, nessun apice singolo, nessuna chiave senza virgolette, nessun NaN, nessun Infinity, nessun undefined. Il valore di livello superiore può essere qualsiasi valore JSON (oggetto, array, stringa, numero, true, false, null).

Per l'input codificato in UTF-8, il formattatore accetta l'intero set di caratteri Unicode; gli ambienti solo ASCII dovrebbero usare gli escape \uXXXX.

Errori comuni e correzioni:

• virgola finale dopo l'ultimo elemento di array/oggetto (rimuovila)
• apici singoli attorno a chiavi o stringhe (sostituisci con doppi apici)
• parentesi graffa o quadra di chiusura mancante (la colonna dell'errore punta vicino al troncamento)
• caratteri di controllo non convalidati nelle stringhe (esegui l'escape con \n, \t, \\)

La minimizzazione rimuove tutti gli spazi bianchi insignificanti — spazi tra i token, rientri e interruzioni di riga — lasciando la rappresentazione più compatta possibile. I risparmi tipici vanno dal 20% al 60% a seconda di quanto era rientrato il tuo JSON sorgente.

Usa il JSON minimizzato per:

• risposte API REST/GraphQL
• messaggi WebSocket
• payload JWT
• blob di configurazione SaaS
• attributi di dati incorporati in HTML

Mantieni il JSON formattato (pretty-printed) per:

• file di configurazione controllati da sorgente
• fixture e snapshot nei test
• documenti modificati da umani

Il JSON minimizzato è comunque JSON standard al 100% — qualsiasi parser conforme lo accetta. Il minificatore qui presente preserva esattamente i dati: nessun riordino delle chiavi, nessuna coercizione dei valori, nessuna perdita di precisione sui numeri all'interno del doppio intervallo IEEE 754.

La pura validazione della sintassi JSON controlla solo che il documento venga analizzato. JSON Schema valida la forma del documento — che 'email' sia una stringa, 'age' sia un numero intero 0–150, 'role' sia uno tra ['admin', 'user', 'guest']. Uno schema è a sua volta un documento JSON che descrive i vincoli; le istanze vengono validate rispetto ad esso.

Parole chiave comuni: type, required, properties, items, enum, pattern (regex), minimum/maximum, minLength/maxLength, format (email, date-time, uri).

Implementazioni di riferimento:

• Ajv (JavaScript, il più veloce)
• jsonschema (Python)
• networknt/json-schema-validator (Java)
• justinrainbow/json-schema (PHP)

La validazione dello schema rileva un'enorme classe di bug al confine delle API: campi obbligatori mancanti, tipi errati, valori fuori intervallo, date malformate. Le specifiche OpenAPI 3.x usano JSON Schema per la validazione di richieste/risposte.

JSONPath sta a JSON come XPath sta a XML — un linguaggio di query per navigare ed estrarre dati da JSON annidati.

Sintassi:

• $ (radice)
• . (figlio)
• .. (discesa ricorsiva)
• [n] (indice dell'array)
• [start:end] (intervallo)
• [?(expression)] (filtro)
• * (caratterer jolly)

Esempi su un tipico JSON di un negozio:

• $.store.book[0].title ottiene il titolo del primo libro
• $..author restituisce ogni autore nell'intero documento
• $.store.book[?(@.price < 10)] filtra i libri che costano meno di 10
• $.store..price[*] appiattisce tutti i prezzi

Strumenti: jq (sintassi leggermente diversa ma stesse funzionalità, dominante nello scripting shell), script di test Postman, JMESPath (--query di AWS CLI) e librerie JSONPath in ogni linguaggio principale.

JSON Lines (jsonlines.org), noto anche come NDJSON o LDJSON, è un formato in cui ogni riga rappresenta un valore JSON completo. Il file nel suo complesso non è un JSON valido, ma lo è ogni singola riga.

È ampiamente utilizzato per lo streaming di log (Loki, Splunk HEC, Vector), pipeline ETL, dati di addestramento per il machine learning (file di fine-tuning di OpenAI) e qualsiasi flusso di dati append-only.

Vantaggi:

• ottimizzato per lo streaming (analizza un record alla volta, memoria costante)
• append-only (basta scrivere la riga successiva)
• compatibile con grep e awk tramite i comuni strumenti Unix

Estensioni dei file: .jsonl, .ndjson. Converti da un array JSON con `jq -c '.[]'`; converti in un array JSON con `jq -s` (slurp). BigQuery, Athena, Snowflake e la maggior parte dei moderni data warehouse importano NDJSON in modo nativo.

JSON5 (json5.org) estende il JSON introducendo funzionalità utili per gli sviluppatori:

• commenti (// e /* */)
• virgole finali
• stringhe con virgolette singoli
• chiavi senza virgolette
• stringhe multilinea (con continuazione tramite backslash)
• numeri esadecimali
• valori speciali IEEE 754 (NaN, Infinity)

NON è compatibile con JSON.parse: richiede un parser JSON5 (pacchetto npm json5, PyJson5).

Usa JSON5 per file di configurazione modificati da persone in cui i commenti sono importanti: babel.config.json5, alcune configurazioni di strumenti di build, .vscode/settings.json (che usa JSONC, un dialetto simile di JSON con commenti).

Attieniti al JSON rigoroso per: API HTTP, interscambio di dati, formati di archiviazione e qualsiasi contenuto generato automaticamente. Mescolare i due approcci crea confusione negli strumenti: scegline uno per file e mantienilo.

Gli errori di analisi JSON più frequenti e le relative soluzioni:

• (1) Virgola finale dopo l'ultimo elemento — `{"a":1,}` o `[1,2,3,]` — rimuovi la virgola superflua.
• (2) Virgolette singole su chiavi o valori di stringa — `{'name':'Alice'}` — devono essere doppie virgolette.
• (3) Chiavi senza virgolette — `{name:"Alice"}` — aggiungi le virgolette.
• (4) Commenti che utilizzano // o /* */ — il JSON rigoroso non li consente; rimuovili o passa a JSON5/JSONC.
• (5) Valori JavaScript non presenti in JSON — undefined, NaN, Infinity, funzioni — sostituisci con null o rimuovi.
• (6) Input troncato — il parser di solito indica la riga in cui è terminato il contenuto atteso.
• (7) BOM (byte-order mark) all'inizio di un file UTF-8 — la maggior parte dei parser lo rifiuta; rimuovilo con `sed -i '1s/^\xEF\xBB\xBF//'`.
• (8) L'uso misto di tabulazioni e spazi non interrompe l'analisi ma rovina i diff — scegli un unico stile di indentazione.

Tre categorie di vulnerabilità legate al JSON che ogni sviluppatore dovrebbe comprendere.

• (1) Inquinamento dei prototipi (prototype pollution): l'unione di JSON non attendibili in un oggetto esistente può inquinare Object.prototype se l'input contiene chiavi __proto__, constructor o prototype, compromettendo ogni oggetto nel runtime. Usa Object.create(null), structuredClone o librerie come defaultsDeep di lodash che bloccano esplicitamente queste chiavi.
• (2) Non usare mai eval() per analizzare JSON: eval esegue qualsiasi codice JavaScript, mentre JSON.parse è isolato in un sandbox. Il mito secondo cui 'eval è più veloce' è stato smentito anni fa.
• (3) Problematiche legate alla ri-serializzazione: JSON.stringify omette silenziosamente funzioni, undefined e valori Symbol dagli oggetti (li converte in null negli array). Genera inoltre un errore con riferimenti circolari e BigInt per impostazione predefinita.

Valida i JSON non attendibili con JSON Schema prima dell'elaborazione, imposta una dimensione massima del corpo sulla tua API e usa i controlli Content-Type per rifiutare tempestivamente gli input non JSON. Il cheat sheet sulla sicurezza REST di OWASP copre l'argomento in modo completo.

JSON ↔ YAML è la conversione più priva di perdite: entrambi supportano oggetti e array nidificati. Fai attenzione alla conversione automatica dei tipi di YAML (yes/no/on/off diventano booleani, i numeri senza virgolette rimangono numeri, la stringa letterale 'null' diventa null). Racchiudi tra virgolette i valori ambigui. Strumenti: js-yaml (npm), PyYAML, yq.

JSON → CSV richiede l'appiattimento della struttura nidificata; funziona al meglio per array di oggetti piatti. Scegli una strategia per i valori nidificati: stringify (scritti come JSON in una cella) o colonne con notazione a punti (`address.city`, `address.zip`). Strumenti: in2csv di csvkit, pandas pd.json_normalize, json2csv (npm).

JSON → XML è semplice per le strutture ad albero ma perde la distinzione tra array e oggetto (i nodi fratelli in XML potrebbero essere entrambi). Attenzione ai nomi degli elementi XML non validi (non possono iniziare con cifre o contenere spazi). Strumenti: xml-js, xmltodict (Python).

Per tutte le conversioni, decidi in anticipo se preservare le informazioni sui tipi o appiattire tutto in stringhe.

JSON.parse carica l'intero documento in memoria, ideale per le normali risposte API ma problematico per file superiori a poche centinaia di megabyte. I parser in streaming elaborano un token (o un record) alla volta, mantenendo la memoria costante indipendentemente dalle dimensioni del file.

• JavaScript: stream-json o oboe.js per l'analisi in stile SAX.
• Python: ijson per l'analisi incrementale, oppure converti prima in JSON Lines e leggi riga per riga.
• Java: Jackson Streaming API (JsonParser).
• Shell: jq elabora JSON in streaming tramite --stream.

Per i file generati come array JSON di record, valuta la possibilità di configurare il produttore in modo da emettere JSON Lines: ogni consumer a valle ne trarrà vantaggio. Quando devi gestire un array JSON enorme in memoria, preferisci l'iterazione e lo scarto dei record piuttosto che la creazione di una struttura dati parallela. Tieni d'occhio la dimensione dell'heap, imposta --max-old-space-size in Node e profila prima di ottimizzare.

Riferimento rapido per le operazioni quotidiane con il JSON.

• Indentazione: prettier e npm usano per impostazione predefinita 2 spazi; scegli 4 per codebase aziendali che già utilizzano un'indentazione di 4 spazi tra diversi linguaggi; i tab sono validi ma rari in JSON.
• Ordinamento delle chiavi (per diff più puliti): JSON.stringify(obj, Object.keys(obj).sort(), 2) per oggetti superficiali; jq --sort-keys per ricorsioni profonde; Python json.dumps(obj, sort_keys=True).
• Confronto (diff) di due file JSON: jq --sort-keys su entrambi i file, quindi esegui il diff standard; oppure usa json-diff (npm), DeepDiff (Python), il confronto integrato in VS Code consapevole del JSON.
• Sequenze di escape nelle stringhe: \\" (doppia virgoletta), \\\\ (backslash), \\/ (slash, opzionale), \\b (backspace), \\f (avanzamento pagina), \\n (nuova riga), \\r (ritorno carrello), \\t (tabulazione), \\uXXXX (punto di codice Unicode).
• Numeri: il JSON consente decimali ed esponenti (1.5e3) ma non zeri iniziali (0123 non è valido) né punti decimali finali (1. non è valido).
• Le stringhe devono essere racchiuse tra doppie virgolette; le virgolette singole sono consentite solo in JSON5.