JSON null-Werte entfernen: Was bleibt, was wird gelöscht

VeröffentlichtToolJSON Nullwert-Bereiniger

Inhalt
  1. Warum eine solche Bereinigung nötig wird
  2. So bereinigen Sie JSON ohne Tool selbst
  3. Was häufig verwechselt wird
  4. Fazit
  5. Technischer Hintergrund: Rekursive Baumtraversierung und Bewertung von Werten
  6. Vergleich: JSON-Bereinigung in verschiedenen Umgebungen (Vergleichstabelle)
  7. Die 5 häufigsten und folgenschwersten Fehler
  8. Der 5-Schritte-Workflow für den Produktiveinsatz
  9. 7 Tipps zum Aufräumen von JSON-Payloads
  10. Entscheidungsbaum: Welche Strategie und welches Werkzeug passen zu Ihnen?
  11. Glossar: Die wichtigsten Begriffe (Terminology Cheatsheet)
  12. Häufig gestellte Fragen

Wenn Sie null, leere Strings (""), leere Arrays ([]) und leere Objekte ({}) aus einer API-Antwort oder Konfigurationsdatei in einem Durchgang herausfiltern möchten, müssen Sie nur eine einzige Regel kennen: Welche Werte gelten als „leer“, und in welcher Reihenfolge wird das geprüft – nämlich von innen nach außen. Dieser Beitrag erklärt diese Regel direkt anhand des Codes.

Kurzfassung ① Entfernt werden nur leere Strings, null, undefined, leere Arrays und leere Objekte. 0, false und nicht leere Strings bleiben erhalten. ② Zuerst werden die untergeordneten Werte bereinigt, dann wird der übergeordnete Wert geprüft. Wird ein verschachteltes Objekt leer, fällt es daher auch auf der nächsthöheren Ebene weg. ③ Da das Standard-JSON.parse verwendet wird, wird die Verarbeitung bei abschließenden Kommas, Schlüsseln ohne Anführungszeichen oder dem Literal undefined schon im Vorfeld abgelehnt.

Warum eine solche Bereinigung nötig wird

Manchmal speichert man eine API-Antwort als JSON-Datei, um sie beim nächsten Durchlauf wiederzuverwenden, oder sammelt die Ergebnisse mehrerer Anfragen in einem Log. Sind optionale Felder leer, steht in der Antwort an dieser Stelle trotzdem null, ein leerer String oder ein leeres Array.

Mit wachsender Dateimenge gibt es mitunter mehr leere Schlüssel als solche mit echten Werten. Vergleichen Sie solche Dateien per Diff oder überfliegen sie am Bildschirm, füllen leere Werte die Ansicht, und die Werte, auf die es ankommt, sind schwer zu finden.

Hinzu kommt: Leere Werte stehen nicht nur auf der obersten Ebene. Häufig sind sie in verschachtelten Objekten oder in Objekten innerhalb von Arrays versteckt. Wer sie Ebene für Ebene von Hand löscht, übersieht leicht Stellen und beschädigt dabei schnell die Struktur.

So bereinigen Sie JSON ohne Tool selbst

Die Bereinigungsregel ist nichts Besonderes und lässt sich mit einer einzigen rekursiven Funktion ausdrücken. Wenn Sie den Code direkt in die Konsole der Entwicklertools Ihres Browsers einfügen, erhalten Sie dasselbe Ergebnis auch ohne Tool.

function isEmpty(v) {
  if (v === "" || v === null || v === undefined) return true;
  if (Array.isArray(v) && v.length === 0) return true;
  if (v && typeof v === "object" && Object.keys(v).length === 0) return true;
  return false;
}

function cleanValues(value) {
  if (Array.isArray(value)) {
    return value.map(cleanValues).filter((v) => !isEmpty(v));
  }
  if (value !== null && typeof value === "object") {
    const result = {};
    for (const [key, val] of Object.entries(value)) {
      const cleaned = cleanValues(val);
      if (!isEmpty(cleaned)) result[key] = cleaned;
    }
    return result;
  }
  return value;
}

const data = JSON.parse(original_json_string);
console.log(JSON.stringify(cleanValues(data), null, 2));

Der Ablauf in Kürze:

  1. Der ursprüngliche JSON-String wird mit JSON.parse geparst. Ist die Syntax fehlerhaft, tritt bereits in diesem Schritt ein Fehler auf. Prüfen Sie deshalb zuerst, ob die Syntax korrekt ist.
  2. Bei einem Array wird zunächst jedes Element rekursiv bereinigt. Anschließend werden nur die Elemente herausgefiltert, deren bereinigtes Ergebnis ein leerer String, null, undefined, ein leeres Array oder ein leeres Objekt ist.
  3. Bei einem Objekt wird zunächst jeder Eigenschaftswert rekursiv bereinigt. Ist der bereinigte Wert nach demselben Kriterium leer, wird der Schlüssel selbst aus dem Ergebnisobjekt weggelassen.
  4. Werte, die weder Array noch Objekt sind (Strings, Zahlen, Booleans), werden unverändert durchgereicht. 0 und false erfüllen keines der Kriterien und bleiben daher erhalten.

Mit unserem Tool prüfen.

JSON Nullwert-Bereiniger

Ohne Anmeldung und Installation: JSON einfügen, und leere Werte werden sofort entfernt.

Was häufig verwechselt wird

Das Kriterium lautet nicht vage „Werte, die leer aussehen“. Entfernt werden ausschließlich Werte, die zu einer genau festgelegten Liste gehören. Die folgende Tabelle fasst das zusammen.

WertErgebnis
"" (leerer String)entfernt
nullentfernt
undefinedentfernt
[] (leeres Array)entfernt
{} (leeres Objekt)entfernt
0bleibt erhalten
falsebleibt erhalten
" " (ein Leerzeichen)bleibt erhalten (kein leerer String)
"0" (String)bleibt erhalten

0 und false bleiben erhalten, weil die Prüffunktion einen Wert exakt nur mit diesen fünf Fällen vergleicht: "", null, undefined, leeres Array und leeres Objekt. 0 und false gehören zu keinem davon und passieren die Prüfung daher unverändert.

Dasselbe gilt für ein einzelnes Leerzeichen (" "). Ein leerer String ("") und ein String mit einem Zeichen sind verschiedene Werte. Ein String, der nur aus einem Leerzeichen besteht, wird deshalb nicht entfernt und bleibt erhalten.

Wenn gar keine Ausgabe erscheint und nur eine rote Fehlermeldung angezeigt wird, liegt das unabhängig von der Bereinigungsregel daran, dass die Eingabe selbst keine gültige JSON-Syntax hat. Häufige Ursachen sind:

  • Nach dem letzten Element steht noch ein Komma (abschließendes Komma, „Trailing Comma“): {"a": 1,}
  • Der Schlüssel steht nicht in Anführungszeichen: {a: 1}
  • Als Wert wurde das Literal undefined geschrieben: {"a": undefined} – in JSON gibt es den Wert undefined gar nicht, gültig ist nur null
  • Strings oder Schlüssel stehen in einfachen Anführungszeichen: {'a': 'b'}

JSON.parse folgt einem strengeren Standard als JavaScript-Objektliterale. Ist eines dieser Probleme enthalten, bricht das Parsen mit einem Fehler ab, und die Logik zum Herausfiltern leerer Werte wird gar nicht erst ausgeführt.

Fazit

  • Entfernt werden genau fünf Arten von Werten: leere Strings, null, undefined, leere Arrays und leere Objekte.
  • 0, false sowie nicht leere Strings, Arrays und Objekte – auch solche mit Leerzeichen – bleiben erhalten.
  • Die Bereinigung läuft von den untergeordneten Werten zum übergeordneten Wert. Wird ein Objekt dadurch leer, weil seine Kinder entfernt wurden, wird auch dieses Objekt im nächsten Schritt entfernt.
  • Die Eingabe wird mit dem Standard-JSON.parse geprüft. Bei abschließenden Kommas, Schlüsseln ohne Anführungszeichen oder dem Literal undefined erscheint daher noch vor der Bereinigung ein Fehler.
JSON Nullwert-Bereiniger

Ohne Anmeldung und Installation: JSON einfügen, und leere Werte werden sofort entfernt.


Technischer Hintergrund: Rekursive Baumtraversierung und Bewertung von Werten

Mit einfachem Ersetzen (Replace) oder regulären Ausdrücken (Regex) allein lassen sich leere Werte in verschachteltem JSON mit unvorhersehbarer Tiefe nicht vollständig entfernen. Der Grund: JSON-Daten bilden von Natur aus eine Baumstruktur (Tree). Im Folgenden sehen wir uns den Algorithmus, der hinter einem Werkzeug zum Entfernen leerer JSON-Werte steckt, seine Komplexität und die Einschränkungen der Standardspezifikation genauer an.

1. Algorithmen zur Baumtraversierung (Tree Traversal)

Das wichtigste Konzept beim Bereinigen von JSON-Daten ist die rekursive Post-Order-Traversierung (Bottom-up Post-order Traversal).

  • Warum Bottom-up (Post-Order) unverzichtbar ist: Zuerst werden die Kindknoten ausgewertet und bearbeitet, anhand des Ergebnisses wird dann der Elternknoten bewertet. Die Reihenfolge lautet cleanValues(child) -> isEmpty(cleanedChild). Nehmen wir die Daten {"parent": {"child": {"grandchild": ""}}}: Der innerste Schlüssel grandchild ist ein leerer String und wird entfernt. Dadurch wird das Objekt child zu einem leeren Objekt {}. Bei der Auswertung von child stellt sich nun heraus, dass es leer ist, und es wird ebenfalls entfernt. Schließlich ist auch parent ein leeres Objekt, sodass am Ende alle Hüllen restlos verschwunden sind.
  • Grenzen der Top-down-Traversierung (Pre-Order): Hier wird zuerst der Elternknoten bewertet. Im obigen Beispiel werden parent und child anfangs als „nicht leer“ eingestuft, weil sie noch Schlüssel enthalten. Entfernt man später die Werte der Kinder, bleiben die Eltern zwar als leere Objekte zurück, doch deren Bewertung ist bereits abgeschlossen. Die Folge ist ein gravierender Mangel: Sinnlose, leere Hüllenobjekte bleiben bestehen.

2. Präzise Unterscheidung der Werte (Value Discrimination Logic)

Falsy-Werte dürfen nicht pauschal gelöscht werden. Entfernt werden sollten nur die wirklich bedeutungslosen leeren Werte, die die Geschäftslogik der Anwendung nicht beeinflussen.

  • Zu entfernende Werte (Pruned values):
    • "" (leerer String)
    • null
    • undefined (kann auftreten, wenn man nach dem JSON-Parsen interne Objekte bearbeitet)
    • [] (leeres Array ohne ein einziges Element)
    • {} (leeres Objekt ohne einen einzigen Schlüssel)
  • Unbedingt zu erhaltende Werte (Preserved falsy primitives):
    • 0 (Die Zahl 0 steht etwa für Kontostände, Mengen oder Indizes und ist daher sehr wichtig)
    • false (Der boolesche Wert false beschreibt eindeutige Zustände wie fehlende Berechtigung, Deaktivierung oder nicht bezahlt)
    • " " (Ein String aus einem Leerzeichen kann eine beabsichtigte Eingabe sein)

3. Zeit- und Speicherkomplexität (Time & Space Complexity)

  • Zeitkomplexität: O(N) – dabei ist N die Gesamtzahl der Knoten (Schlüssel-Wert-Paare) im JSON-Baum. Jeder Knoten wird genau einmal durchlaufen und geprüft, daher wächst der Aufwand linear mit der Datenmenge.
  • Speicherkomplexität: O(D) – dabei ist D die maximale Verschachtelungstiefe (Maximum Nesting Depth) des Baums. Bei jedem Aufruf der rekursiven Funktion wächst der Call Stack, sodass bei sehr tief verschachteltem JSON ein Stack Overflow auftreten kann. Die Tiefe typischer API-Antworten überschreitet jedoch nicht 10 Ebenen, deshalb ist das Verfahren in der Praxis sehr sicher und schnell.

4. Einschränkungen durch den JSON-Standard RFC 8259

Am Anfang dieses Bereinigungsalgorithmus muss immer JSON.parse() stehen. Der Standard RFC 8259 verlangt für die Integrität des Datenaustauschs eine sehr strenge Syntax. Folgende Elemente sind in JavaScript erlaubt, in Standard-JSON aber niemals zulässig (sie lösen einen SyntaxError aus):

  • Komma nach der letzten Eigenschaft eines Arrays oder Objekts (Trailing Commas)
  • Einfache Anführungszeichen (') um Strings oder Objektschlüssel
  • Objektschlüssel ohne Anführungszeichen
  • Spezielle Zahlenliterale wie NaN, Infinity, -Infinity
  • Die direkte Verwendung des Schlüsselworts undefined

Für eine vollständige Bereinigung muss deshalb stets zuerst ein standardkonform serialisierter String eingelesen und geparst werden.


Vergleich: JSON-Bereinigung in verschiedenen Umgebungen (Vergleichstabelle)

Die folgende Übersicht stellt Vorteile, Nachteile und Funktionsumfang der gängigen Methoden zum Entfernen leerer JSON-Werte in verschiedenen Umgebungen und Bibliotheken gegenüber.

VergleichskriteriumPure Recursive JS (empfohlen)JSON.stringify(obj, replacer)Lodash (_.omitBy / _.pickBy)jq-Shell-Filter (CLI)
FunktionsweiseVollständiger rekursiver Post-Order-AlgorithmusFilterung während der SerialisierungOberflächliche Filterung von ObjekteigenschaftenBaumtraversierung mit der Funktion walk
Entfernen verschachtelter leerer Eltern✅ Vollständig unterstützt (Bottom-up)❌ Nicht möglich (Grenze des Top-down-Ansatzes)❌ Nicht möglich (wirkt nur auf 1 Ebene)✅ Vollständig unterstützt (rekursives walk)
Erhalt von 0 und false✅ Vollständig unterstützt (explizite Typprüfung)✅ Unterstützt (bedingte Verarbeitung möglich)⚠️ Vorsicht (bei _.identity gehen sie verloren)✅ Vollständig unterstützt (!= null)
Leere Elemente in Arrays✅ Werden sauber herausgefiltert, das Array wird verkürzt⚠️ Werden durch null ersetzt (Arraylänge bleibt erhalten)❌ Auf Array-Elemente nicht anwendbar✅ Mit map und select möglich
Verarbeitungsgeschwindigkeit und PerformanceSehr schnell (lineare Suche mit O(N))Schnell (optimiert durch die native C++-Engine)Etwas langsamer (Overhead der Bibliothek)Schnell (kompiliertes Binary auf C-Basis)
Geeignete EinsatzumgebungBrowser-Frontend, Node.js-BackendLog-Formatierung, einfache flache DatenProjekte, die Lodash bereits als Abhängigkeit nutzenServer-Zugriff per SSH, Automatisierung mit Bash-Skripten

Wie die Tabelle zeigt, arbeitet die Funktion replacer, das zweite Argument von JSON.stringify, von oben nach unten. Sie kann daher einen leeren Elternknoten, dessen Kinder gerade entfernt wurden, nicht erkennen und löschen. Außerdem verschwinden Array-Elemente nicht vollständig, sondern ihr Platz wird mit null aufgefüllt. Eine rekursive eigene Funktion (Pure Recursive JS) ist deshalb im Hinblick auf die Datenintegrität deutlich überlegen.


Die 5 häufigsten und folgenschwersten Fehler

Selbst erfahrene Senior-Entwickler übersehen Randfälle (Edge Cases) und begehen Fehler, die einem Dienst erheblich schaden können.

  1. Übermäßiger Einsatz einer einfachen Truthy/Falsy-Prüfung (if (!value)) Wer sich auf die flexible Typumwandlung von JavaScript verlässt und mit if (!value) prüft, verliert die Zahl 0 aus der Datenbank (z. B. Kontostand 0 Won) und false (z. B. Ablehnung von Marketing-Einwilligungen) komplett – die Geschäftslogik bricht zusammen.
  2. Leere Hüllenobjekte bleiben durch Top-down-Filterung zurück Prüft die Logik zuerst das Elternobjekt, wird ein neues leeres Elternobjekt ({ "user": {} }), das erst durch das Entfernen leerer Werte der Kindknoten entsteht, nicht erfasst. Die Optimierung der Payload-Größe misslingt.
  3. Direkte Änderung des Originalobjekts (In-place Mutation) mit Nebenwirkungen (Side Effects) Wird das Originalobjekt in der rekursiven Funktion mit delete obj[key] direkt verändert, drohen unerwartete Fehler bei Speicherreferenzen und inkonsistente Zustände, sobald andere Module der Anwendung dasselbe Objekt referenzieren. Halten Sie sich an Unveränderlichkeit (Immutability) und geben Sie immer ein neues Objekt zurück.
  4. Fehlender Schutz vor Zirkelbezügen (Circular References) Verweist Objekt A auf Objekt B und B wiederum auf A (z. B. bei bidirektionalen ORM-Modellen) und übergeben Sie eine solche Struktur an die Bereinigungsfunktion, rekursiert diese endlos, bis der Fehler Maximum call stack size exceeded auftritt und der gesamte Node.js-Server abstürzt.
  5. Ungesicherter Aufruf von JSON.parse() ohne Fehlerbehandlung Wird Text von außen ungeprüft an JSON.parse() übergeben und tritt ein Syntaxfehler (Syntax Error) auf, stürzt die Anwendung ab. Umgeben Sie den Aufruf unbedingt mit einem try-catch-Block oder verwenden Sie eine sichere Wrapper-Funktion.

Der 5-Schritte-Workflow für den Produktiveinsatz

Über das reine Bereinigen hinaus beschreibt dieser Ablauf eine systematische Pipeline in fünf Schritten, mit der Sie JSON in Unternehmensumgebungen sicher verarbeiten und speichern.

  • Schritt 1: Schema und Syntax vorab prüfen (Syntax Validation) Versuchen Sie zunächst, die eingehende Zeichenkette per try-catch zu parsen, um zu prüfen, ob sie der Spezifikation RFC 8259 entspricht. Bei Bedarf bauen Sie mit einem Schema-Validator wie Ajv oder Zod eine erste Verteidigungslinie auf, die sicherstellt, dass die Grundstruktur der Daten Ihren Erwartungen entspricht.
  • Schritt 2: Bottom-up-Bereinigung per Rekursion ausführen (Bottom-Up Pruning) Rufen Sie eine rekursive Funktion wie cleanValues aus dem Hauptteil auf. Sie entfernt bedeutungslose Knoten wie null, "", [] und {} vollständig, beginnend bei den tiefsten Ebenen.
  • Schritt 3: Erhalt der wichtigen Falsy-Werte (0, false) gegenprüfen Prüfen Sie per Unit-Test, ob im bereinigten Objekt geschäftskritische Werte wie 0 oder false erhalten geblieben sind. Gerade bei Payloads aus dem Finanz- oder Authentifizierungsbereich darf dieser Schritt nicht fehlen.
  • Schritt 4: Für die Zielumgebung optimiert serialisieren (Serialization) Wandeln Sie das bereinigte, reine JavaScript-Objekt je nach Zweck (Übertragung oder Speicherung) in eine Zeichenkette um. Für die Netzwerkübertragung im Produktivbetrieb verwenden Sie JSON.stringify(cleaned, null, 0) ohne Leerraum. Müssen Menschen Logs lesen, verbessern Sie die Lesbarkeit mit JSON.stringify(cleaned, null, 2).
  • Schritt 5: Dauerhaft speichern und sicher an nachgelagerte APIs ausliefern Das nun schlanke JSON-Payload ohne überflüssigen Ballast laden Sie in PostgreSQL oder MongoDB oder senden es sicher als API-Antwort an Client oder Server.

7 Tipps zum Aufräumen von JSON-Payloads

Dies sind fortgeschrittene Techniken erfahrener Entwickler, um in Systemen mit hohem Traffic Leistung im Millisekundenbereich (ms) herauszuholen.

  1. Beim Senden von API-Antworten im Produktivbetrieb die Einrückung komplett entfernen: Wenn Sie nicht gerade debuggen, setzen Sie beim Erzeugen von API-Antworten eine kompakte Serialisierung ein, die alle unnötigen Zeilenumbrüche (\n) und Leerzeichen entfernt. Bei großen JSON-Dokumenten kann der Anteil von Leerraum am Gesamtvolumen sogar über 20 % liegen.
  2. null-Felder bei GraphQL- und REST-Antworten unmittelbar vor dem Senden entfernen (Strip): Leere null-Felder, die nur wegen des Schemas künstlich mitgeschickt werden, verbrauchen lediglich Netzwerkbandbreite. Wenden Sie die Bereinigungsfunktion zentral in einer Middleware oder einem Interceptor Ihres Frameworks an, um die Antwortgröße zu minimieren.
  3. Für die Kommunikation zwischen Microservices schemabasierte Serialisierung einsetzen: In Node.js können Sie den CPU-Overhead bei der Kommunikation zwischen internen Services erheblich senken, wenn Sie statt des nativen JSON.stringify eine Bibliothek mit vorkompiliertem Schema wie fast-json-stringify verwenden.
  4. Webhook-Payloads vor der dauerhaften Speicherung in der Datenbank unbedingt bereinigen (Sanitize): Wenn Sie große Webhook-Pakete externer Zahlungsanbieter oder Partner-APIs unverändert in eine JSON-Spalte einer relationalen Datenbank schreiben, steigen die Speicherkosten schnell an. Speichern Sie ausschließlich bereinigte Daten, die nur das Wesentliche enthalten.
  5. Zirkuläre Referenzen mit einem WeakSet vermeiden und erkennen: Wenn Sie komplexe Objekte aus dem Arbeitsspeicher in JSON umwandeln oder bereinigen, sollten Sie einen Schutz einbauen, damit der Call Stack nicht überläuft: Speichern Sie beim Eintritt in die rekursive Funktion das aktuelle Objekt in einem WeakSet und prüfen Sie, ob es schon besucht wurde.
  6. Den Zeitpunkt der Serialisierung von ISO-8601-Date-Objekten steuern: Damit die Bereinigungsfunktion ein JavaScript-Date-Objekt nicht fälschlich für ein leeres Objekt {} hält und löscht, ergänzen Sie innerhalb der Verzweigung typeof value === "object" eine Ausnahme mit value instanceof Date, oder serialisieren Sie das Datum vor der Bereinigung in eine Zeichenkette.
  7. Grenzfälle und komplexe Daten mit diesem Web-Tool testen: Bevor Sie mehrere tausend Zeilen verschachteltes JSON direkt im Code verarbeiten, fügen Sie es in das Bereinigungstool auf dieser Seite ein und prüfen Sie zuerst mit eigenen Augen, ob 0, false und Objekte in Arrays wie gewünscht erhalten bleiben. Machen Sie das zur Gewohnheit.

Entscheidungsbaum: Welche Strategie und welches Werkzeug passen zu Ihnen?

Passend zu Ihrer Entwicklungsumgebung und Ihren Anforderungen finden Sie hier in Sekunden die beste Methode zum Entfernen leerer Werte.

  • Situation A (Shell-Umgebung, CI/CD-Pipeline, DevOps-Loganalyse) ➔ Den walk-Filter von jq verwenden: In der Kommandozeile ist es am effizientesten, ohne Browser die Daten per Pipe (|) weiterzureichen und direkt ein Bereinigungsskript wie walk(if type == "object" then ...) auszuführen.
  • Situation B (einfache, flache Konfigurationsdateien, nicht tief verschachtelte Daten) ➔ _.omitBy aus lodash oder eine Replacer-Funktion von JSON.stringify nutzen: Bei flachen Objekten, die keine tiefe Rekursion erfordern, ist es sinnvoll, vorhandene Utility-Bibliotheken im Projekt oder native Funktionen zu nutzen und so Boilerplate-Code zu sparen.
  • Situation C (tiefe Verschachtelung, Komprimierung von API-Antworten, Finanzdaten mit höchsten Integritätsanforderungen) ➔ Die im Hauptteil gezeigte rekursive Funktion cleanValues (Bottom-up) implementieren: Müssen auch leere Objekte innerhalb von Objekten vollständig entfernt werden und hat der Erhalt von 0 und false absolute Priorität, ist eine eigene rekursive Logik die einzig richtige Lösung.
  • Situation D (einmalige, schnelle Datenbereinigung ohne Programmieren, mit übersichtlicher Darstellung) ➔ Den JSON Nullwert-Bereiniger (Web-Tool) dieser Website verwenden: Wenn Sie keine Zeit für die Installation einer Bibliothek aufwenden wollen und sofort sauberes JSON für Excel oder einen Bericht brauchen, ist das die beste Wahl.

Glossar: Die wichtigsten Begriffe (Terminology Cheatsheet)

Sechs zentrale Begriffe, damit Sie sich im komplexen Umfeld des Data Engineering zurechtfinden.

  • Rekursive Post-order-Traversierung (Bottom-up Post-order Traversal): Ein Algorithmus zur Baumtraversierung, der zuerst die tiefsten Kindknoten verarbeitet und danach schrittweise die Elternknoten auswertet. Das ist das Kernprinzip beim Entfernen verschachtelter leerer Objekte.
  • Falsy-Wert (Falsy Value): Ein Wert, der in JavaScript in einem booleschen Kontext als false ausgewertet wird (false, 0, -0, 0n, "", null, undefined, NaN).
  • RFC 8259: Die aktuelle offizielle IETF-Spezifikation des Formats JavaScript Object Notation (JSON), das weltweit die Grundlage des Datenaustauschs im Internet bildet.
  • JSON.stringify-Replacer: Eine Callback-Funktion oder ein Array, das als zweites Argument übergeben wird, um beim Umwandeln eines JavaScript-Objekts in einen JSON-String bestimmte Eigenschaften herauszufiltern oder zu verändern.
  • Zirkuläre Referenz (Circular Reference): Ein Zustand, in dem ein Objekt direkt oder indirekt wieder auf sich selbst verweist. Wird ein solches Objekt serialisiert oder rekursiv verarbeitet, entsteht eine Endlosschleife mit einem schwerwiegenden Fehler.
  • Payload-Optimierung (Payload Optimization): Das Entfernen von unnötigem Leerraum und bedeutungslosen leeren Schlüsseln aus den Datenpaketen (Payloads), die Client und Server über das Netzwerk austauschen, um Übertragungsgeschwindigkeit und Kosten deutlich zu verbessern.

Häufig gestellte Fragen

Hier finden Sie drei tiefergehende Fragen samt Antworten, die über die reine Neugier hinaus erklären, wie das Ganze funktioniert.

Q1. Warum dürfen „0“ und „false“ nicht entfernt werden, und wie behandelt man sie als Ausnahme?

A1. In der API-Kommunikation hat „0“ eine zentrale Bedeutung für die Geschäftslogik: 0 % Rabatt, 0 Won Kontostand oder der Index 0 eines Arrays. Auch „false“ steht für etwas Konkretes, etwa eine fehlgeschlagene Authentifizierung oder eine deaktivierte Funktion. Wenn Sie diese Werte löschen, interpretiert das System sie fälschlich als null oder undefined, also als „Daten wurden noch nicht erfasst“. Das kann zu fehlenden Zahlungen oder zu Fehlern führen, die Berechtigungsprüfungen umgehen. Um das zu verhindern, sollte die Prüffunktion (isEmpty) nicht mit einem pauschalen Negationsoperator wie if (!value) arbeiten. Stattdessen sollte sie die zu entfernenden Werte explizit benennen (Strict Equality), etwa mit v === "" || v === null || v === undefined, damit keine Typumwandlung stattfindet.

Q2. Ich habe ein Objekt mit fünf Verschachtelungsebenen. Nachdem ich den leeren Wert im innersten Kind entfernt habe, sind auch alle Elternobjekte leer. Wie entferne ich alles in einem Durchgang?

A2. Sie müssen das JSON „bottom-up“ (von unten nach oben) statt „top-down“ (von oben nach unten) durchlaufen. Der native Replacer von JavaScript arbeitet sich von oben nach unten vor. Er erkennt daher nicht, dass ein Elternobjekt, das er bereits passiert hat, nachträglich leer wird. Die Funktion cleanValues aus dem Artikel entscheidet dagegen erst, nachdem sie den Rückgabewert des rekursiven Aufrufs erhalten hat, ob dieser dem Elternschlüssel zugewiesen wird (if (!isEmpty(cleaned)) result[key] = cleaned;). Verschwindet also das innerste Kind und das Elternobjekt wird zu {}, erkennt isEmpty auf der Ebene des Großelternobjekts das zuverlässig und löscht es.

Q3. Lässt sich die rekursive Bereinigung in der Bash-Shell auch mit jq genauso vollständig durchführen?

A3. Ja, das funktioniert vollständig. Verwenden Sie dafür die eingebaute Funktion walk, die ab jq 1.5 verfügbar ist. walk durchläuft die Struktur intern in einer vollständigen Post-order-Traversierung. Geben Sie in der Shell Folgendes ein:

jq 'walk(if type == "object" then with_entries(select(.value != null and .value != "" and .value != [] and .value != {})) else . end)' input.json

Mit dieser einen Zeile lassen sich auch mehrere Gigabyte große Dumps, etwa aus Linux-Server-Monitoring-Logs oder Cron-Jobs, in kürzester Zeit vollständig verkleinern.

Dieser Artikel basiert auf unserem koreanischen Original. Koreanisches Original lesen

Ähnliche Artikel

  1. A-Record vs. CNAME: Unterschied erklärt und Format prüfenA-Record verweist auf eine IPv4-Adresse, CNAME auf einen anderen Domainnamen. So unterscheiden sich beide in der Zonendatei und so prüfen Sie Ihre Eingabe.
  2. CSS-Akkordeon erstellen: Checkbox-Hack ohne JavaScript erklärtSo funktioniert ein CSS-Akkordeon ohne JavaScript: Checkbox- und Radio-Hack im Code erklärt, mit Live-Vorschau sowie HTML- und CSS-Code zum Kopieren.
  3. Doppelte CSS-Selektoren finden und zusammenführenWenn ein CSS-Selektor mehrfach vorkommt, überschreibt der spätere Wert den früheren. So finden Sie Duplikate per grep und führen sie automatisch zusammen.
  4. CSS minifizieren: Was entfernt wird und was erhalten bleibtBeim CSS-Minify entfallen Kommentare und überflüssige Leerzeichen, Strings und calc() bleiben intakt. Dazu: so wird die Ersparnis in Prozent berechnet.
  5. CSS perspective 3D-Karte erstellen: Reihenfolge der transform-WerteSo wirken perspective, rotateX, rotateY, rotateZ, translateZ und scale in einem transform zusammen – mit Schiebereglern und Live-CSS-Code zum Kopieren.
  6. CSS-Spezifität berechnen: Priorität von Selektoren (A-B-C)So berechnet sich die CSS-Spezifität als A-B-C-Wert: Punkte für ID, Klasse und Tag, Regeln für :not() und :where() – mit Rechner zum direkten Nachprüfen.

Passende Tools