JSON afvlakken

Scheidingsteken:
Max. diepte:(0=unlimited)

Online tool om JSON af te vlakken en te herstellen: zet geneste JSON met één klik om in platte sleutel-waardeparen gescheiden door punten. Aangepast scheidingsteken, array-indexen uitvouwen en omgekeerd herstellen, alles lokaal verwerkt voor maximale veiligheid.

Gerelateerde aanbevelingen

Toepassingsgevallen

  • MongoDB-query's en aggregaties: zet geneste JSON om in een platte puntstructuur en gebruik die direct in find, update en aggregatiepijplijnen, zonder paden handmatig te typen
  • CSV/Excel-export: vlak een object met meerdere niveaus af en importeer het in een Pandas DataFrame of Excel, met de sleutels als kolomkoppen, één record per rij
  • Elasticsearch-indexering: platte documenten zijn beter geschikt voor opslag en zoekopdrachten; alle geneste array-velden worden uitgevouwen tot platte sleutels
  • API-debugging: vergelijk de geneste structuur van verzoek en respons; na het afvlakken zijn veldnamen leesbaarder, waardoor ontbrekende velden en typefouten sneller opvallen
  • Preprocessing van configuraties: vlak bestanden als package.json of settings.json af tot omgevingsvariabelen, klaar om in Docker- of CI-pijplijnen te injecteren
  • Logs en monitoring: vlak complexe, geneste logevents af voordat u ze naar een datawarehouse schrijft, zodat aggregatie en visualisatie per veld eenvoudiger worden

Hoe te gebruiken

  1. Plak de te verwerken JSON in het invoerveld links, upload een lokaal .json-bestand via de uploadknop, of klik op voorbeeld om een geneste sample te laden
  2. Schakel in de werkbalk tussen de modi "Afvlakken" en "Herstellen" en stel in de opties onderaan het scheidingsteken, de array-verwerking en de maximale uitvoudiepte in
  3. De tool verwerkt in realtime: het uitvoerveld rechts toont direct het resultaat, samen met de sleuteltelling en de maximale diepte
  4. Klik op Kopiëren om het resultaat naar het klembord te schrijven, of op Downloaden om het als .json-bestand lokaal op te slaan

Functies

  • Bidirectionele conversie: ondersteunt JSON afvlakken en herstellen, zodat u zonder verlies kunt schakelen tussen geneste en platte structuren
  • Aangepast scheidingsteken: standaard punt, maar ondersteunt underscore, slash, dubbele underscore of een willekeurig teken, zodat het past bij diverse downstream-systemen
  • Configureerbare array-verwerking: vouw ze uit tot index-sleutels (bijv. items.0.items.1) of behoud de hele array als één waarde, voor zowel tabel- als configuratiescenario's
  • Maximale dieptelimiet: stel een bovengrens in voor de uitvouw om te voorkomen dat diep geneste structuren extreem lange sleutels genereren
  • Realtime statistieken: toont direct na verwerking het aantal sleutels en de maximale diepte, zodat u de omvang van de uitvoer kunt inschatten
  • Lokale verwerking voor privacy: parseren en transformaties vinden plaats in de browser; JSON-data wordt nooit naar een server gestuurd, ideaal voor gevoelige API's en productieconfiguraties
  • Bestand uploaden en voorbeelden: ondersteunt .json-bestanden en biedt een voorbeeld dat met één klik geladen kan worden om de conversie direct te valideren
  • Kopiëren en downloaden: kopieer het resultaat met één klik naar het klembord of download het als standaard .json-bestand voor verdere verwerking

Codevoorbeelden

JSON afvlakken 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' }

JSON afvlakken 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"}

JSON afvlakken via de commandline met jq

bash
# Zet geneste JSON om in een platte puntstructuur
jq '[paths(scalars) as $p | {"key": $p | join("."), "value": getpath($p)}] | from_entries' data.json

# Om een platte JSON terug te zetten naar een geneste structuur
# Vereist jq 1.7+ met filters van derden, of gebruik de modus "Herstellen" van deze tool

Veelgestelde vragen

Wat is JSON afvlakken en wanneer heb je het nodig?

JSON afvlakken is het proces waarbij objecten of arrays die in meerdere niveaus genest zijn, worden omgezet in sleutel-waardeparen op één niveau. De namen van de geneste sleutels worden samengevoegd met een scheidingsteken (standaard de punt). Bijvoorbeeld: {"user":{"name":"Alice"}} wordt {"user.name":"Alice"}. Je hebt het nodig wanneer je geneste JSON naar CSV wilt exporteren, dot-notation query's in MongoDB wilt schrijven, in Elasticsearch wilt indexeren, omgevingsvariabelen wilt configureren of moet koppelen met downstream-systemen die alleen platte sleutels accepteren.

Kan de geneste structuur vanuit een platte JSON worden hersteld?

Ja. Deze tool bevat de unflatten-modus: zolang u hetzelfde scheidingsteken gebruikt als bij het afvlakken, herstelt u zonder verlies het oorspronkelijke geneste object en de arrays. Opeenvolgende integer-indexen (0, 1, 2…) worden automatisch herkend en als array teruggezet, zonder handmatige configuratie.

Wordt een aangepast scheidingsteken ondersteund? Hoe worden arrays behandeld?

Ja. Het scheidingsteken kan een punt, underscore, slash, dubbele underscore of een willekeurig teken zijn, tot 3 tekens lang. Voor arrays zijn er twee modi: standaard worden ze uitgevouwen in numerieke sleutels (items.0, items.1); vink de optie aan om de hele array als één waarde te behouden. Daarnaast kunt u een maximale uitvoudiepte instellen (0 = geen limiet): boven het opgegeven niveau blijft de geneste structuur compact, zodat sleutels niet te lang worden.

Brengt het online verwerken van JSON de privacy in gevaar?

Nee. Parsen, afvlakken en herstellen vinden volledig plaats in uw lokale browser. De JSON-data wordt nooit naar een server gestuurd. Productie-API's, live configuraties en persoonlijke gegevens verlaten uw apparaat niet tijdens de hele bewerking.

Hoe gebruik je JSON afvlakken met MongoDB?

MongoDB gebruikt standaard de dot-notation om geneste velden te benaderen. Wilt u bijvoorbeeld documenten opvragen waarin user.contact.email gelijk is aan alice@example.com, dan gebruikt u { "user.contact.email": "alice@example.com" }. Nadat u een geneste JSON met deze tool naar een platte structuur hebt omgezet, kunt u de resulterende sleutels direct in find-query's, update-opdrachten en aggregatiepijplijnen plakken, zodat u de paden niet meer handmatig hoeft te typen.

Hoe exporteer je een afgevlakte JSON naar CSV of Excel?

De uitvoer van het afvlakken is al een sleutel-waardemap op één niveau. U kunt deze direct kopiëren naar onze tool JSON naar CSV, of in Excel of Pandas importeren met de puntsleutels als kolomkoppen. Voor arrays van objecten is het aan te raden de dieptelimiet te gebruiken of de array compact te houden, zodat één record niet in meerdere rijen wordt opgesplitst.

In welke scenario's kies je voor underscore of slash als scheidingsteken?

De punt (user.address.city) is het meest universeel, geschikt voor JS-objecten en MongoDB-query's. De underscore (user_address_city) is ideaal voor SQL-kolomnamen, Python-variabelen en omgevingsvariabelen. De slash (user/address/city) lijkt op een bestandspad en wordt vaak gebruikt in path-parameters van REST API's. De dubbele underscore (user__address__city) is geschikt voor frameworks zoals Django, waar de underscore al in sleutels voorkomt.

Kan een sleutel die zelf een punt of underscore bevat conflicten veroorzaken?

Ja. Een oorspronkelijke sleutel user.name die met de punt als scheidingsteken wordt afgevlakt, wordt user.name.name; bij het herstellen zou die worden gesplitst in user → name → name, wat een ongewenste extra laag oplevert. Wanneer sleutels het scheidingsteken bevatten, kiest u beter een scheidingsteken dat niet in sleutels voorkomt (zoals slash of dubbele underscore) of past u vóór de bewerking een escape/rename toe op de sleutels.

Hoe worden objecten binnen arrays uitgevouwen?

Standaard worden ze uitgevouwen op basis van numerieke indexen: een array orders met twee objecten levert orders.0.id, orders.0.total, orders.1.id, orders.1.total op. Als uw downstream-systeem een platte tabel verwacht, komt deze structuur direct overeen met meerdere rijen in CSV. Bij het herstellen worden opeenvolgende integer-indexen (0, 1, 2…) automatisch als array herkend, zonder extra opties.

Loopt het vast bij hele grote JSON-bestanden?

De tool draait in de browser: gangbare API-respons (van tientallen tot honderden KB) worden in seconden verwerkt. Voor bestanden van enkele MB of groter is het aan te raden commandline-tools zoals jq lokaal te gebruiken om geheugenproblemen in de browser te voorkomen. Wilt u toch online verwerken, comprimeer of beperk dan eerst de velden voordat u ze plakt, of splits het bestand op in meerdere batches.

Waarvoor dient de maximale dieptelimiet?

De maximale dieptelimiet beperkt het uitvouwen tot een bepaald niveau: nesting voorbij die drempel blijft compact als één waarde. Het heeft twee veelvoorkomende toepassingen: het voorkomen van te lange sleutels in diepe configuraties en het respecteren van de maximale lengte van kolomnamen in sommige databases (bijvoorbeeld SQL Server, met een limiet van 128 tekens). De standaardwaarde is 0 (geen limiet); pas deze aan naar behoefte.

Kan het resultaat worden opgeslagen of hergebruikt?

Ja. Na de verwerking kunt u het resultaat met één klik naar het klembord kopiëren of downloaden als standaard .json-bestand. Alles verloopt lokaal: u hoeft geen account aan te maken en er wordt niets aan de serverzijde opgeslagen.

Probleemoplossing

Melding "Invoer is geen geldige JSON"

Oorzaak: de JSON-tekst bevat syntaxfouten, zoals ontbrekende aanhalingstekens, overtollige komma's, niet-gesloten haakjes of booleans in Python-stijl (True/False). Oplossing: gebruik de JSON-formatteer- of validatietools uit onze toolkit om de syntax te controleren. Onthoud: booleans en null moeten in kleine letters en zonder aanhalingstekens staan, en sleutels moeten dubbele aanhalingstekens gebruiken.

Sleutelbotsing na afvlakken en verkeerde lagen bij herstellen

Oorzaak: een oorspronkelijke sleutel bevat al het gekozen scheidingsteken (bijvoorbeeld user.name met de punt als scheidingsteken), waardoor er een extra laag ontstaat bij het splitsen. Oplossing: kies een scheidingsteken dat niet in sleutelnamen voorkomt (slash, dubbele underscore of een aangepast teken), of pas vóór de bewerking een escape/rename toe op de sleutels.

Na het uitvouwen van arrays bevat de CSV-export meer rijen dan verwacht

Oorzaak: standaard worden array-elementen uitgevouwen in numerieke index-sleutels, wat voor elk element een set sleutel-waardeparen oplevert; in combinatie met de overige velden levert dat meerdere records op. Oplossing: wilt u één object per rij, vink dan "Behoud de hele array als één waarde" aan, of geef in de CSV-tool op dat het array-veld niet uitgevouwen mag worden. Wilt u juist één array-element per rij, dan is dit het verwachte gedrag.

Het herstellen levert niet de verwachte array op

Oorzaak: alleen sleutels met opeenvolgende integer-indexen (0, 1, 2…) worden als array hersteld; sleutels als orders.first of orders.second worden als object herkend. Oplossing: wijzig bij het afvlakken de numerieke indexen niet, of zet de array-velden handmatig terug naar de vorm orders.0, orders.1 met zuivere numerieke indexen voordat u herstelt.

Te lange sleutels of afgekapte kolomnamen in de database

Oorzaak: een diep geneste JSON kan na afvlakken pad-sleutels opleveren die de maximale lengte van kolomnamen in databases zoals SQL Server of PostgreSQL overschrijden. Oplossing: stel in de tool-opties de "Maximale uitvoudiepte" in: voorbij het opgegeven niveau blijft de nesting compact. U kunt de geneste structuur ook opsplitsen of diepe sleutels hernoemen vóór de verwerking.

Browser vertraagt of crasht bij grote bestanden

Oorzaak: zeer grote JSON (tientallen MB of meer) verbruikt veel geheugen in de browser, wat kan leiden tot een niet-reagerende pagina of crash. Oplossing: splits het bestand op of gebruik commandline-tools zoals jq, flatten-json of Python-scripts. Deze tool is geoptimaliseerd voor API-respons, configuraties en logregels van gangbare grootte.