JSON.parse()

Probieren Sie es aus

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json);

console.log(obj.count);
// Expected output: 42

console.log(obj.result);
// Expected output: true

Syntax

JSON.parse(text)
JSON.parse(text, reviver)

Parameter

text

Die Zeichenfolge, die als JSON analysiert werden soll. Eine Beschreibung der JSON-Syntax finden Sie beim Objekt JSON.

reviver Optional

Falls eine Funktion angegeben wird, legt sie fest, wie jeder beim Analysieren erzeugte Wert vor der Rckgabe transformiert wird. Werte, die nicht aufgerufen werden knnen, werden ignoriert. Die Funktion wird mit folgenden Argumenten aufgerufen:

key

Der dem Wert zugeordnete Schlssel.

value

Der beim Analysieren erzeugte Wert.

context

Ein Kontextobjekt mit Informationen zum aktuellen Ausdruck, dessen Wert wiederhergestellt wird. Bei jedem Aufruf der Reviver-Funktion wird ein neues Objekt erstellt.

source Optional

Die ursprngliche JSON-Zeichenfolge, die diesen Wert darstellt. Diese Eigenschaft ist nur bei der Wiederherstellung primitiver Werte vorhanden, nicht jedoch, wenn value ein Objekt oder Array ist.

Rckgabewert

Der dem angegebenen JSON-text entsprechende Wert: ein Object, ein Array, eine Zeichenfolge, eine Zahl, ein boolescher Wert oder null.

Ausnahmen

SyntaxError

Wird ausgelst, wenn die zu analysierende Zeichenfolge kein gltiges JSON ist.

Beschreibung

JSON.parse() analysiert eine JSON-Zeichenfolge gem der JSON-Grammatik und wertet sie anschlieend wie einen JavaScript-Ausdruck aus. Nur beim Schlssel "__proto__" kann ein JSON-Text einen anderen Wert darstellen als der entsprechende JavaScript-Ausdruck siehe Objektliteral-Syntax im Vergleich zu JSON.

Der Parameter reviver

Wenn ein reviver angegeben ist, wird der beim Analysieren ermittelte Wert vor der Rckgabe transformiert. Dazu werden der ermittelte Wert und alle seine Eigenschaften einzeln an den reviver bergeben. Die Verarbeitung erfolgt in Tiefensuche: Sie beginnt bei den am tiefsten verschachtelten Eigenschaften und endet beim ursprnglichen Wert selbst.

Der reviver wird mit dem Objekt, das die gerade verarbeitete Eigenschaft enthlt, als this und mit drei Argumenten aufgerufen: key, value und context. Wenn Sie den reviver als Pfeilfunktion definieren, gibt es keine eigene this-Bindung. Der Schlssel ist auch bei Arrays eine Zeichenfolge. Bei primitiven Werten enthlt das Argument context ein Feld namens source mit dem ursprnglichen Text dieses Werts. Gibt die reviver-Funktion undefined oder keinen Wert zurck etwa weil das Ende der Funktion erreicht wird , wird die Eigenschaft aus dem Objekt gelscht. Andernfalls erhlt die Eigenschaft den zurckgegebenen Wert. Wenn der reviver nur bestimmte Werte transformiert, mssen Sie alle unvernderten Werte unverndert zurckgeben. Andernfalls werden sie aus dem Ergebnis gelscht.

hnlich wie beim Parameter replacer von JSON.stringify() wird reviver bei Arrays und Objekten zuletzt fr den Wurzelwert aufgerufen, mit einer leeren Zeichenfolge als key und dem Wurzelobjekt als value. Bei anderen gltigen JSON-Werten wird reviver entsprechend einmal aufgerufen, mit einer leeren Zeichenfolge als key und dem Wert selbst als value.

Wenn Sie aus reviver einen anderen Wert zurckgeben, ersetzt dieser den ursprnglich analysierten Wert vollstndig. Das gilt auch fr den Wurzelwert. Beispiel:

const transformedObj = JSON.parse('[1,5,{"s":1}]', (key, value) =>
  typeof value === "object" ? undefined : value,
);

console.log(transformedObj); // undefined

Dafr gibt es keine allgemeingltige Umgehung. Sie knnen den Fall eines leeren key nicht einfach gesondert behandeln, da JSON-Objekte ebenfalls Schlssel enthalten knnen, die leere Zeichenfolgen sind. Bei der Implementierung des Revivers mssen Sie daher genau wissen, welche Transformation fr jeden Schlssel erforderlich ist.

Beachten Sie, dass reviver erst nach dem Analysieren des Werts ausgefhrt wird. Zahlen im JSON-Text wurden zu diesem Zeitpunkt beispielsweise bereits in JavaScript-Zahlen umgewandelt und haben dabei mglicherweise an Genauigkeit verloren. Eine Mglichkeit, groe Zahlen ohne Genauigkeitsverlust zu bertragen, besteht darin, sie als Zeichenfolgen zu serialisieren und anschlieend als BigInts oder in einem anderen geeigneten Format mit beliebiger Genauigkeit wiederherzustellen.

Sie knnen auch ber die Eigenschaft context.source auf den ursprnglichen JSON-Quelltext zugreifen, der den Wert darstellt, wie im folgenden Beispiel gezeigt:

const bigJSON = '{"gross_gdp": 12345678901234567890}';
const bigObj = JSON.parse(bigJSON, (key, value, context) => {
  if (key === "gross_gdp") {
    // Ignore the value because it has already lost precision
    return BigInt(context.source);
  }
  return value;
});

Beispiele

JSON.parse() verwenden

JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null

Den Parameter reviver verwenden

JSON.parse(
  '{"p": 5}',
  (key, value) =>
    typeof value === "number"
      ? value * 2 // return value * 2 for numbers
      : value, // return everything else unchanged
);
// { p: 10 }

JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', (key, value) => {
  console.log(key);
  return value;
});
// 1
// 2
// 4
// 6
// 5
// 3
// ""

reviver zusammen mit dem replacer von JSON.stringify() verwenden

Damit ein Wert nach der Serialisierung und Deserialisierung wieder dem ursprnglichen Objekt entspricht, muss die Serialisierung die Typinformationen bewahren. Dazu knnen Sie beispielsweise den Parameter replacer von JSON.stringify() verwenden:

// Maps are normally serialized as objects with no properties.
// We can use the replacer to specify the entries to be serialized.
const map = new Map([
  [1, "one"],
  [2, "two"],
  [3, "three"],
]);

const jsonText = JSON.stringify(map, (key, value) =>
  value instanceof Map ? Array.from(value.entries()) : value,
);

console.log(jsonText);
// [[1,"one"],[2,"two"],[3,"three"]]

const map2 = JSON.parse(jsonText, (key, value) =>
  Array.isArray(value) && value.every(Array.isArray) ? new Map(value) : value,
);

console.log(map2);
// Map { 1 => "one", 2 => "two", 3 => "three" }

Da die JSON-Syntax keine Mglichkeit bietet, Typmetadaten anzugeben, mssen Sie zur Wiederherstellung von Werten, die keine einfachen Objekte sind, eine der folgenden Mglichkeiten in Betracht ziehen:

• Das gesamte Objekt als Zeichenfolge serialisieren und ein Typkennzeichen voranstellen.
• Den Typ aus der Datenstruktur erraten (beispielsweise bei einem Array aus Arrays mit jeweils zwei Elementen).
• Bei fest vorgegebener Struktur der Daten den Typ anhand des Eigenschaftsnamens bestimmen (beispielsweise wenn alle Eigenschaften namens registry Map-Objekte enthalten).

Ungltiges JSON

Wenn JSON.parse eine Zeichenfolge erhlt, die nicht der JSON-Grammatik entspricht, wird ein SyntaxError ausgelst.

Arrays und Objekte drfen in JSON keine abschlieenden Kommas enthalten:

JSON.parse("[1, 2, 3, 4, ]");
// SyntaxError: Unexpected token ] in JSON at position 13

JSON.parse('{"foo": 1, }');
// SyntaxError: Unexpected token } in JSON at position 12

JSON-Zeichenfolgen mssen durch doppelte Anfhrungszeichen begrenzt sein, nicht durch einfache:

JSON.parse("{'foo': 1}");
// SyntaxError: Unexpected token ' in JSON at position 1

JSON.parse("'string'");
// SyntaxError: Unexpected token ' in JSON at position 0

Wenn Sie JSON innerhalb eines JavaScript-Zeichenfolgenliterals schreiben, sollten Sie entweder das JavaScript-Zeichenfolgenliteral durch einfache Anfhrungszeichen begrenzen oder die doppelten Anfhrungszeichen des JSON-Texts maskieren:

JSON.parse('{"foo": 1}'); // OK
JSON.parse("{\"foo\": 1}"); // OK

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill fr das moderne Verhalten von JSON.parse (Parameter context des Revivers) in core-js
• JSON.stringify()