Aplanar JSON

Separador:
Profunditat màxima:(0=unlimited)

Transforma JSON imbricat en claus planes amb separador i recupera l'estructura original quan ho necessitis. Tot el processament es fa de manera segura al navegador.

Relacionats

Casos d'ús

  • Consultes i actualitzacions de MongoDB: utilitza claus amb punts sense escriure manualment totes les rutes imbricades
  • Exportació a CSV i Excel: converteix JSON multinivell en columnes planes per a tractament tabular
  • Preparació de dades per a Elasticsearch: simplifica documents molt imbricats abans d'indexar-los
  • Depuració d'API: compara camps de petició i resposta en una mateixa vista plana
  • Pretractament de configuració i variables d'entorn: desplega ajustos imbricats de package.json o settings.json

Com usar-ho

  1. Enganxa el JSON al panell esquerre o carrega un fitxer .json local
  2. Tria el mode flatten o unflatten i configura el separador, els arrays i la profunditat màxima
  3. Revisa el resultat al panell dret juntament amb el nombre de claus i la profunditat
  4. Copia el resultat o descarrega'l com a fitxer .json

Característiques

  • Conversió en dues direccions: permet tant flatten com unflatten per moure's entre estructures imbricades i planes
  • Separador personalitzat: fes servir punts, guions baixos, barres o qualsevol altre caràcter segons el sistema de destinació
  • Gestió flexible d'arrays: pots expandir els elements per índex o conservar tot l'array com un sol valor
  • Límit de profunditat: atura l'expansió al nivell que vulguis per evitar claus massa llargues
  • Processament local segur: el JSON no s'envia al servidor, tot passa dins del navegador
  • Flux de treball pràctic: admet càrrega de .json, dades d'exemple, còpia del resultat i descàrrega del fitxer

Exemples de codi

Aplanar JSON amb 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' }

Aplanar JSON amb 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"}

Aplanar JSON amb jq a la terminal

bash
# Converteix JSON imbricat en una estructura plana amb claus separades per punts
jq '[paths(scalars) as $p | {"key": $p | join("."), "value": getpath($p)}] | from_entries' data.json

# Recupera el JSON pla com a estructura imbricada
# Fes servir jq 1.7+ amb un filtre extern o el mode unflatten d'aquesta eina

Preguntes freqients

Què és aplanar JSON i quan ho necessito?

Aplanar JSON converteix objectes i arrays imbricats en parells clau-valor d'un sol nivell. Va molt bé per a consultes de MongoDB, exportacions CSV, indexació a Elasticsearch, variables d'entorn i comparació de camps d'API.

Es pot recuperar l'estructura original després d'aplanar?

Sí. Si fas servir el mateix separador, l'eina reconstrueix objectes i arrays a partir de les claus planes. Les claus numèriques consecutives es detecten automàticament com a arrays.

Puc canviar el separador i la manera de tractar els arrays?

Sí. Pots triar punt, guió baix, barra, guió baix doble o un separador propi. Els arrays es poden expandir com `items.0`, `items.1` o bé conservar-se sencers.

És segur processar JSON en línia?

Sí. Tota l'anàlisi i la conversió es fan localment al navegador, de manera que el JSON no es puja a cap servidor extern.

Com es fa servir el resultat a MongoDB?

MongoDB accedeix als camps imbricats amb notació de punts. Les claus generades per aquesta eina es poden reutilitzar directament a `find`, `update` i els pipelines d'agregació.

El resultat serveix per a CSV i Excel?

Sí. Un cop aplanat, tots els camps queden al mateix nivell i és molt més fàcil passar-los a JSON to CSV, Excel o Pandas com a columnes.

Què passa si la clau original ja conté punts o el mateix separador?

Això pot provocar conflictes en reconstruir l'estructura. És millor fer servir un altre separador o escapar prèviament les claus conflictives.

Pot gestionar fitxers JSON molt grans?

Les respostes d'API normals i els fitxers de configuració habituals funcionen bé. Si el JSON és molt gran, convé dividir-lo o fer servir una eina local com `jq`.

Solució de problemes

L'eina diu que l'entrada no és un JSON vàlid

Normalment hi ha un problema de sintaxi: cometes que falten, comes sobrants, parèntesis sense tancar o valors com True/False. Comprova primer el text amb un formatejador JSON.

Després de fer unflatten, l'estructura surt malament

És probable que les claus originals ja continguessin el separador seleccionat. Canvia de separador o escapa abans les claus conflictives.

Quan expandeixo arrays, el CSV queda massa ample

Expandir per índex genera molts camps addicionals. Si vols una taula més compacta, conserva l'array complet com un únic valor.

Un JSON molt gran alenteix el navegador

Els fitxers JSON molt grans consumeixen molta memòria. Divideix les dades o utilitza eines locals com `jq`, Python o Node.js.