Appiattimento JSON

Separatore:
Profondità max.:(0=unlimited)

Strumento online per appiattire e ripristinare JSON: converti JSON annidato in coppie chiave-valore separate da punti con un clic. Separatore personalizzato, espansione indici array e ripristino inverso, tutto in locale per la massima sicurezza.

Raccomandazioni correlate

Casi d'uso

  • Query e aggregazioni MongoDB: converti JSON annidato in struttura piatta con punti e usalo direttamente in find, update e pipeline di aggregazione, senza scrivere i percorsi a mano
  • Esportazione CSV/Excel: dopo aver appiattito un oggetto su più livelli, importalo in un DataFrame Pandas o in Excel usando le chiavi come intestazioni di colonna, mantenendo un record per riga
  • Indicizzazione Elasticsearch: i documenti piatti sono più adatti all'archiviazione e all'interrogazione nei motori di ricerca, espandendo tutti i campi array nidificati in chiavi piatte
  • Debug di API: confronta la struttura annidata di richiesta e risposta; dopo l'appiattimento i nomi dei campi sono più leggibili e aiutano a individuare campi mancanti o errori di tipo
  • Pre-elaborazione configurazioni: appiattisci file come package.json o settings.json in variabili d'ambiente, pronte per essere iniettate in pipeline Docker o CI
  • Log e monitoraggio: appiattisci eventi di log complessi e nidificati prima di scriverli in un data warehouse, per semplificare le aggregazioni e la visualizzazione per campo

Come utilizzare

  1. Incolla il JSON da elaborare nella casella di input a sinistra, oppure carica un file .json locale tramite il pulsante di upload, o clicca sull'esempio per caricare un campione annidato
  2. Nella barra degli strumenti passa dalla modalità "Appiattisci" a "Ripristina" e, nelle opzioni in basso, imposta separatore, gestione degli array e profondità massima di espansione
  3. Lo strumento elabora in tempo reale: l'area di output a destra mostra subito il risultato insieme al conteggio delle chiavi e alla profondità massima
  4. Clicca sul pulsante Copia per salvare il risultato negli appunti, oppure su Download per salvarlo come file .json sul tuo computer

Funzionalità

  • Conversione bidirezionale: supporta appiattimento e de-appiattimento JSON, per passare senza perdite tra strutture annidate e piatte
  • Separatore personalizzato: punto di default, ma supporta underscore, slash, doppio underscore o qualsiasi carattere, adattandosi a diversi sistemi a valle
  • Gestione array configurabile: espandili in chiavi indicizzate (es. items.0.items.1) oppure mantienili come valore singolo, per coprire sia scenari tabellari sia configurativi
  • Limite di profondità massima: imposta un tetto massimo di espansione per evitare chiavi troppo lunghe in strutture molto annidate
  • Statistiche in tempo reale: al termine dell'elaborazione mostra immediatamente numero di chiavi e profondità massima, per valutare la dimensione dell'output
  • Elaborazione locale per la privacy: parsing e trasformazioni avvengono nel browser, dati JSON mai inviati a server, ideale per API sensibili e configurazioni di produzione
  • Caricamento file ed esempi: supporta file .json e offre un esempio pronto da caricare per verificare subito la conversione
  • Copia e download: copia il risultato negli appunti con un clic o scaricalo come file .json standard per elaborazioni successive

Esempi di codice

Appiattimento JSON in JavaScript

javascript
function flatten(obj, prefix = '', sep = '.') {
  return Object.entries(obj).reduce((acc, [key, value]) => {
    const newKey = prefix ? `${prefix}${sep}${key}` : key;
    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
      Object.assign(acc, flatten(value, newKey, sep));
    } else {
      acc[newKey] = value;
    }
    return acc;
  }, {});
}

flatten({ user: { name: 'Alice', contact: { email: 'a@x.com' } } });
// => { 'user.name': 'Alice', 'user.contact.email': 'a@x.com' }

Appiattimento JSON in Python

python
def flatten(obj, parent_key='', sep='.'):
    items = {}
    for key, value in obj.items():
        new_key = f"{parent_key}{sep}{key}" if parent_key else key
        if isinstance(value, dict):
            items.update(flatten(value, new_key, sep))
        else:
            items[new_key] = value
    return items

import json
print(json.dumps(flatten({'user': {'name': 'Alice'}}), indent=2))
# => {"user.name": "Alice"}

Appiattimento JSON da riga di comando con jq

bash
# Converte JSON annidato in struttura piatta con punti
jq '[paths(scalars) as $p | {"key": $p | join("."), "value": getpath($p)}] | from_entries' data.json

# Per ripristinare la struttura annidata da JSON piatto
# Serve jq 1.7+ con filtri di terze parti, oppure usa la modalità "Ripristina" di questo strumento

Domande frequenti

Cos'è l'appiattimento JSON e quando serve?

L'appiattimento JSON è il processo che trasforma oggetti o array annidati su più livelli in coppie chiave-valore su un unico livello. I nomi delle chiavi annidate vengono concatenati con un separatore (il punto di default). Ad esempio {"user":{"name":"Alice"}} diventa {"user.name":"Alice"}. Ti serve quando devi esportare JSON annidato in CSV, scrivere query dot notation su MongoDB, indicizzare in Elasticsearch, configurare variabili d'ambiente o interfacciarti con sistemi a valle che accettano solo chiavi piatte.

È possibile ripristinare la struttura annidata da un JSON piatto?

Sì. Questo strumento include la modalità di de-appiattimento: basta mantenere lo stesso separatore usato in fase di appiattimento per riottenere senza perdite l'oggetto e gli array annidati originali. Riconosce automaticamente indici interi consecutivi (0, 1, 2…) e li ripristina come array, senza intervento manuale.

È supportato un separatore personalizzato? Come vengono trattati gli array?

Sì. Il separatore può essere un punto, underscore, slash, doppio underscore o qualsiasi carattere, fino a 3 caratteri. Gli array offrono due modalità: per default vengono espansi in chiavi numeriche (items.0, items.1), oppure puoi spuntare l'opzione per mantenere l'intero array come valore singolo. È inoltre possibile impostare una profondità massima di espansione (0 = nessun limite): oltre il livello indicato la struttura annidata resta compatta, evitando chiavi troppo lunghe.

L'elaborazione online del JSON compromette la privacy?

No. Parsing, appiattimento e de-appiattimento avvengono interamente nel browser locale. I dati JSON non vengono mai inviati a un server. JSON di API di produzione, configurazioni live e dati personali restano sul tuo dispositivo per tutta la durata dell'operazione.

Come si usa l'appiattimento JSON con MongoDB?

MongoDB usa di default la dot notation per accedere ai campi annidati. Ad esempio, per interrogare i documenti in cui user.contact.email è alice@example.com si usa { "user.contact.email": "alice@example.com" }. Dopo aver convertito un JSON annidato in struttura piatta con questo strumento, le chiavi ottenute si possono incollare direttamente nelle query find, negli aggiornamenti update e nelle pipeline di aggregazione, eliminando la scrittura manuale dei percorsi.

Come si esporta in CSV o Excel un JSON appiattito?

L'output dell'appiattimento è già una mappa chiave-valore su un unico livello, quindi può essere copiato direttamente nel nostro strumento JSON in CSV, oppure importato in Excel o Pandas usando le chiavi con punto come intestazioni di colonna. Per gli array di oggetti è consigliabile usare il limite di profondità o mantenere l'array compatto, per evitare che un singolo record venga spezzato in più righe.

In quali scenari è meglio usare underscore o slash come separatore?

Il punto (user.address.city) è il più universale, adatto a oggetti JS e query MongoDB. L'underscore (user_address_city) è ideale per nomi di colonne SQL, variabili Python e variabili d'ambiente. Lo slash (user/address/city) ricorda un percorso ed è usato spesso nei parametri di path delle REST API. Il doppio underscore (user__address__city) è adatto a framework come Django, dove l'underscore è già presente nelle chiavi.

Una chiave che contiene già un punto o un underscore può creare conflitti?

Sì. Ad esempio una chiave originaria user.name, appiattita con il punto come separatore, diventerebbe user.name.name; in fase di de-appiattimento verrebbe spezzata in user → name → name, aggiungendo un livello indesiderato. Quando le chiavi contengono il carattere separatore, conviene usare un separatore che non appare nei nomi (ad esempio slash o doppio underscore) oppure effettuare un escape/rinominazione delle chiavi prima dell'operazione.

Come vengono espansi gli oggetti contenuti negli array?

Di default sono espansi tramite indici numerici: ad esempio un array orders con due oggetti produce orders.0.id, orders.0.total, orders.1.id, orders.1.total. Se il sistema a valle richiede una tabella piatta, questa struttura corrisponde direttamente a più righe in CSV. In fase di de-appiattimento gli indici interi consecutivi (0, 1, 2…) vengono riconosciuti e ripristinati automaticamente come array, senza opzioni aggiuntive.

L'elaborazione di JSON molto grandi rallenta?

Lo strumento lavora nel browser: le risposte API di uso comune (da decine a centinaia di KB) vengono elaborate in un secondo. Per file di diversi MB è consigliabile usare strumenti da riga di comando come jq in locale, per evitare pressioni sulla memoria del browser. Se devi comunque elaborarli online, prova a comprimerli o ridurre i campi prima di incollarli, oppure suddividi il file in più lotti.

A cosa serve il limite di profondità massima?

Il limite di profondità massima mantiene l'espansione entro un certo livello: le nidificazioni oltre la soglia vengono mantenute compatte come valore singolo. Ha due impieghi comuni: evitare chiavi troppo lunghe in configurazioni molto profonde e rispettare i limiti di lunghezza dei nomi di colonna di alcuni database (ad esempio SQL Server, che ha un tetto di 128 caratteri). Il valore di default è 0 (nessun limite); modificalo in base alle tue esigenze.

È possibile salvare o riutilizzare il risultato?

Sì. Al termine dell'elaborazione puoi copiare il risultato negli appunti con un clic oppure scaricarlo come file .json standard. Tutto avviene in locale: non serve registrarsi e nessun dato viene memorizzato lato server.

Risoluzione dei problemi

Messaggio "L'input non è JSON valido"

Causa: il testo JSON contiene errori di sintassi, come virgolette mancanti, virgole in eccesso, parentesi non chiuse o valori booleani scritti in stile Python (True/False). Soluzione: usa gli strumenti di formattazione/validazione JSON inclusi nel nostro kit per verificare la sintassi. Ricorda che i booleani e null devono essere minuscoli e senza virgolette, e le chiavi devono usare le doppie virgolette.

Conflitti tra chiavi dopo l'appiattimento e livelli errati nel de-appiattimento

Causa: una chiave originaria contiene già il separatore scelto (ad esempio user.name con il punto come separatore), generando un livello extra in fase di suddivisione. Soluzione: usa un separatore che non appare nei nomi delle chiavi (slash, doppio underscore o un carattere personalizzato), oppure applica un escape o una sostituzione alle chiavi prima dell'operazione.

Dopo l'espansione degli array il CSV esportato contiene più righe del previsto

Causa: per default gli elementi dell'array sono espansi in chiavi con indice numerico e generano un set di coppie chiave-valore per ciascun elemento, che moltiplicato dagli altri campi produce più record. Soluzione: se vuoi un oggetto per riga, spunta "Mantieni l'intero array come valore singolo", oppure indica nello strumento CSV di non espandere il campo array. Se invece vuoi un elemento dell'array per riga, il comportamento è quello atteso.

Il de-appiattimento non restituisce l'array atteso

Causa: solo le chiavi con indici interi consecutivi (0, 1, 2…) vengono ripristinate come array; chiavi come orders.first o orders.second vengono riconosciute come oggetto. Soluzione: durante l'appiattimento non rinominare gli indici numerici, oppure ripristina manualmente i nomi delle chiavi degli array nella forma orders.0, orders.1 con indici puramente numerici prima del de-appiattimento.

Chiavi troppo lunghe o nomi di colonna troncati dal database

Causa: un JSON molto annidato, una volta appiattito, può produrre chiavi-percorso che superano il limite di lunghezza dei nomi di colonna di database come SQL Server o PostgreSQL. Soluzione: imposta nelle opzioni dello strumento la "Profondità massima di espansione": oltre il livello indicato la nidificazione viene mantenuta compatta. In alternativa, scomponi la struttura nidificata o rinomina le chiavi profonde prima dell'elaborazione.

Il browser rallenta o si blocca su file di grandi dimensioni

Causa: JSON molto grandi (decine di MB o più) occupano molta memoria nel browser, causando blocchi o crash della pagina. Soluzione: suddividi il file in più parti oppure affidati a strumenti da riga di comando come jq, flatten-json o script Python. Questo strumento è ottimizzato per risposte API, configurazioni e voci di log di dimensioni comuni.