JSON mit JSON.stringify serialisieren

JSON.stringify() konvertiert einen JavaScript-Wert in eine JSON-Zeichenkette —— um ihn im Body einer Anfrage zu senden, in einer Datei zu speichern oder in localStorage abzulegen. Es klingt einfach, aber seine drei Argumente, die Behandlung spezieller Werte und der toJSON-Hook bringen Entwickler immer wieder zum Stolpern. Dieser Guide behandelt alles, was JSON.stringify() tut, die Entsprechungen in anderen Sprachen und die Fallen, die man vermeiden sollte.

Was JSON.stringify tut

Es geht einen Wert rekursiv durch und erzeugt eine spec-konforme JSON-Zeichenkette. Die Standardausgabe ist kompakt, ohne überflüssigen Whitespace:

const user = { name: "Ada", age: 36, active: true };

JSON.stringify(user);
// '{"name":"Ada","age":36,"active":true}'

Da es immer gültiges JSON ausgibt, sollten Sie niemals JSON-Zeichenketten von Hand bauen mit Konkatenation oder Template Literals —— das ist die häufigste Ursache für [object Object]-Fehler und Trailing-Comma-Fehler.

Die drei Argumente

JSON.stringify(value, replacer, space) nimmt einen Wert plus zwei optionale Argumente, die die meisten Entwickler nie verwenden —— die aber mächtig sind.

space —— Pretty-Print

Das dritte Argument steuert die Einrückung. Übergeben Sie eine Zahl für so viele Leerzeichen oder eine Zeichenkette wie '\t' für Tabulatoren:

JSON.stringify(user, null, 2);
// {
//   "name": "Ada",
//   "age": 36,
//   "active": true
// }

Genau so macht man Pretty-Print von JSON im Code —— siehe JSON formatieren. Lassen Sie das Argument weg (oder übergeben Sie 0), um zu minifizieren; siehe JSON minifizieren.

replacer —— filtern und transformieren

Das zweite Argument kann ein Array von Schlüsseln zum Einschließen sein oder eine Funktion, die jeden Wert transformiert:

// Whitelist: nur diese Schlüssel überleben
JSON.stringify(user, ['name', 'active']);
// '{"name":"Ada","active":true}'

// Funktion: ein Feld maskieren, ein anderes verwerfen
JSON.stringify(
  { name: "Ada", password: "secret", token: "abc" },
  (key, value) => {
    if (key === 'password') return '[REDACTED]';
    if (key === 'token') return undefined; // undefined zurückgeben lässt den Schlüssel weg
    return value;
  },
);
// '{"name":"Ada","password":"[REDACTED]"}'

Der toJSON-Hook

Wenn ein Wert eine toJSON()-Methode hat, ruft JSON.stringify() sie auf und serialisiert stattdessen den Rückgabewert. So werden Date-Objekte automatisch zu ISO-Strings:

JSON.stringify({ when: new Date('2026-05-24T00:00:00Z') });
// '{"when":"2026-05-24T00:00:00.000Z"}'  ← Date.prototype.toJSON wurde ausgeführt

// Eigenes toJSON für angepasste Serialisierung
class Money {
  constructor(cents) { this.cents = cents; }
  toJSON() { return (this.cents / 100).toFixed(2); }
}
JSON.stringify({ price: new Money(1999) });
// '{"price":"19.99"}'

Was verworfen oder umgewandelt wird

JSON hat nur sechs Typen, also werden JavaScript-Werte ohne JSON-Entsprechung still verworfen oder konvertiert —— eine häufige Bug-Quelle bei Round-Trips:

Für die vollständige Liste der Unterschiede zwischen JSON und JavaScript-Objekten siehe JSON vs JavaScript-Objekte.

Häufige Fallen

Zirkuläre Referenzen werfen

const a = {};
a.self = a;
JSON.stringify(a);
// TypeError: Converting circular structure to JSON

// Lösung: ein Replacer, der gesehene Objekte verfolgt, oder die Daten umstrukturieren

BigInt wird nicht unterstützt

JSON.stringify({ id: 9007199254740993n });
// TypeError: Do not know how to serialize a BigInt

// Lösung: zuerst in String konvertieren oder einen Replacer hinzufügen
JSON.stringify({ id: 9007199254740993n }, (k, v) =>
  typeof v === 'bigint' ? v.toString() : v
);

Große Ganzzahlen verlieren Präzision beim Round-Trip

Zahlen über 2⁵³ können nicht exakt dargestellt werden. Wenn Sie eine große Integer-ID stringifizieren und dann parsen, kann sie sich ändern. Speichern Sie solche IDs als Strings.

Nachbar-APIs: structuredClone, der reviver und Stable Stringify

• structuredClone —— für In-Memory-Deep-Copies verwenden Sie nicht JSON.parse(JSON.stringify(x)). structuredClone behandelt Date, Map, Set, ArrayBuffer und zirkuläre Referenzen nativ und ist viel schneller.
• Das reviver-Argument von JSON.parse ist das Spiegelbild des replacer hier. Verwenden Sie sie zusammen für verlustfreie Round-Trips bei Typen, die JSON nicht modelliert —— z. B. kodieren Sie Date im replacer als ISO-String und rehydrieren ihn im reviver.
• Stable-Stringify-Bibliotheken (z. B. json-stable-stringify, fast-json-stable-stringify) —— erzeugen unabhängig von der Einfügereihenfolge der Schlüssel dieselbe Zeichenkette. Verwenden Sie sie, wenn die Ausgabe gehasht, signiert oder als Text verglichen wird (siehe RFC 8785 / JCS für die formelle Version).

Stringify in anderen Sprachen

# Python
import json
json.dumps({"name": "Ada"})                       # kompakt
json.dumps({"name": "Ada"}, indent=2)             # pretty
json.dumps({"name": "Ada"}, separators=(',', ':')) # minified

// Go
import "encoding/json"
b, _ := json.Marshal(map[string]string{"name": "Ada"})

// Ruby
require 'json'
{ name: "Ada" }.to_json

JSON im Browser stringifizieren

Müssen Sie einen JSON-Wert in ein String-Literal escapen —— um ihn in Code, eine DB-Spalte oder einen Shell-Befehl einzubetten? Das JSON-Stringify-Tool von fixjson erledigt das sofort, in Ihrem Browser, ohne Daten an einen Server zu senden.

Häufig gestellte Fragen

Wie mache ich Pretty-Print mit JSON.stringify?

Übergeben Sie ein drittes Argument: JSON.stringify(value, null, 2) für 2 Leerzeichen oder '\t' für Tabulatoren. Siehe JSON formatieren.

Warum verwirft JSON.stringify einige meiner Eigenschaften?

Eigenschaften mit Werten undefined, Funktion oder Symbol werden ausgelassen, weil JSON keine Darstellung dafür hat. Verwenden Sie einen Replacer oder konvertieren Sie sie zuerst.

Wie stringifiziere ich einen Wert mit BigInt?

JSON.stringify() wirft bei BigInt. Stellen Sie einen Replacer bereit, der .toString() auf BigInt-Werten aufruft, und parsen Sie sie auf der anderen Seite bewusst zurück.

Was ist der Unterschied zwischen JSON.stringify und JSON.parse?

stringify wandelt einen Wert in eine JSON-Zeichenkette; parse wandelt eine JSON-Zeichenkette in einen Wert. Sie sind Umkehrungen voneinander. Für Parsing-Fallen siehe Kaputtes JSON in JavaScript behandeln.

Wie stringifiziere ich eine Map oder ein Set?

Standardmäßig serialisieren beide als "{}" —— eine Map hat keine eigenen aufzählbaren Eigenschaften und ein Set stringifiziert sich als leeres Objekt. Konvertieren Sie sie zuerst in eine JSON-freundliche Form (oder über einen replacer):

// Map → Array von [key, value]-Paaren (round-trippable)
JSON.stringify([...myMap]);
// oder mit einem Replacer:
JSON.stringify({ data: myMap }, (k, v) =>
  v instanceof Map ? Object.fromEntries(v) :
  v instanceof Set ? [...v] : v
);

Beim Zurück-Konvertieren bauen Sie mit new Map(arr) / new Set(arr) in einem JSON.parse-Reviver wieder auf, da reines JSON keine Map/Set-Typen hat.

Probieren Sie es aus

• JSON Stringify —— escapen Sie einen JSON-Wert in ein String-Literal, im Browser
• JSON formatieren —— Pretty-Print mit dem space-Argument
• JSON minifizieren —— die kompakte Form und wann sie hilft
• Was ist JSON? —— die sechs Typen, die Stringify erzeugen kann