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

Der String, der als JSON analysiert werden soll. Siehe das JSON-Objekt fr eine Beschreibung der JSON-Syntax.

reviver Optional

Wenn es sich um eine Funktion handelt, legt diese fest, wie jeder Wert, der ursprnglich durch das Parsen erzeugt wurde, vor der Rckgabe transformiert wird. Nicht-aufrufbare Werte werden ignoriert. Die Funktion wird mit den folgenden Argumenten aufgerufen:

key

Der Schlssel, der mit dem Wert verknpft ist.

value

Der durch das Parsen erzeugte Wert.

context Optional

Ein Kontextobjekt, das den Status enthlt, der fr den aktuellen Ausdruck relevant ist, der wiederbelebt wird. Es ist ein neues Objekt fr jeden Aufruf der Reviver-Funktion. Es wird nur beim Wiederbeleben primitiver Werte bergeben, jedoch nicht, wenn value ein Objekt oder Array ist. Es enthlt folgende Eigenschaft:

source

Der ursprngliche JSON-String, der diesen Wert darstellt.

Rckgabewert

Der Object, Array, String, die Zahl, der Boolean oder der null-Wert, der dem gegebenen JSON-text entspricht.

Ausnahmen

SyntaxError

Wird ausgelst, wenn der zu parsende String kein gltiges JSON ist.

Beschreibung

JSON.parse() analysiert einen JSON-String entsprechend der JSON-Grammatik und bewertet den String, als ob er ein JavaScript-Ausdruck wre. Der einzige Fall, in dem ein JSON-Text einen anderen Wert darstellt als der gleiche JavaScript-Ausdruck, tritt bei dem Schlssel "__proto__" auf siehe Objektliteral-Syntax vs. JSON.

Der Reviver-Parameter

Wenn ein reviver angegeben ist, wird der durch das Parsen berechnete Wert transformiert, bevor er zurckgegeben wird. Insbesondere werden der berechnete Wert und alle seine Eigenschaften (in einer Tiefensuche beginnend mit den am tiefsten verschachtelten Eigenschaften weiter zur ursprnglichen Wert selbst) einzeln durch den reviver gefhrt.

Der reviver wird mit dem Objekt aufgerufen, das die zu verarbeitende Eigenschaft enthlt, als this (es sei denn, Sie definieren den reviver als Arrow-Funktion, in diesem Fall gibt es keine separate this-Bindung) und zwei Argumenten: key und value, die den Eigenschaftsnamen als String (auch fr Arrays) und den Eigenschaftswert darstellen. Fr primitive Werte wird ein zustzlicher context-Parameter bergeben, der den Quelltext dieses Wertes enthlt. Wenn die reviver-Funktion undefined zurckgibt (oder keinen Wert zurckgibt zum Beispiel, wenn die Ausfhrung am Ende der Funktion endet), wird die Eigenschaft aus dem Objekt gelscht. Andernfalls wird die Eigenschaft neu definiert, um der Rckgabewert zu sein. Wenn der reviver nur einige Werte transformiert und andere nicht, sollten alle untransformierten Werte unverndert zurckgegeben werden andernfalls werden sie aus dem resultierenden Objekt gelscht.

hnlich wie beim replacer-Parameter von JSON.stringify() wird reviver bei Arrays und Objekten zuletzt auf den Wurzelwert mit einem leeren String als key und dem Wurzelobjekt als value aufgerufen. Fr andere gltige JSON-Werte funktioniert reviver hnlich und wird einmal mit einem leeren String als key und dem Wert selbst als value aufgerufen.

Wenn Sie einen anderen Wert von reviver zurckgeben, ersetzt dieser Wert den ursprnglich geparsten Wert vollstndig. Dies gilt auch fr den Wurzelwert. Ein Beispiel:

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

console.log(transformedObj); // undefined

Es gibt keine generische Mglichkeit, dies zu umgehen. Sie knnen den Fall, bei dem key ein leerer String ist, nicht speziell behandeln, da JSON-Objekte auch Schlssel haben knnen, die leere Strings sind. Sie mssen sehr genau wissen, welche Art von Transformation fr jeden Schlssel erforderlich ist, wenn Sie den Reviver implementieren.

Beachten Sie, dass reviver ausgefhrt wird, nachdem der Wert geparst wurde. So werden beispielsweise Zahlen im JSON-Text bereits in JavaScript-Zahlen konvertiert und knnen dabei an Genauigkeit verlieren. Eine Mglichkeit, groe Zahlen ohne Genauigkeitsverlust zu bertragen, ist, sie als Strings zu serialisieren und sie in BigInts oder andere geeignete Formate mit beliebiger Genauigkeit wiederzubeleben.

Sie knnen auch die Eigenschaft context.source verwenden, um auf den ursprnglichen JSON-Quelltext zuzugreifen, der den Wert darstellt, wie unten 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

Verwendung von JSON.parse()

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

Verwendung des Reviver-Parameters

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
// ""

Verwendung des Revivers in Kombination mit dem Replacer von JSON.stringify()

Damit ein Wert ordnungsgem "round-tript" (d.h. er wird auf das gleiche ursprngliche Objekt deserialisiert), muss der Serialisierungsprozess die Typinformationen beibehalten. Beispielsweise knnen Sie hierfr den replacer-Parameter 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 JSON keinen syntaktischen Raum zur Annotation von Typ-Metadaten hat, mssen Sie eine der folgenden Mglichkeiten in Betracht ziehen, um Werte zu beleben, die keine einfachen Objekte sind:

• Serialisieren Sie das gesamte Objekt zu einem String und versehen Sie es mit einem Typ-Tag.
• "Erraten" basierend auf der Struktur der Daten (z. B. ein Array von Zweier-Arrays)
• Wenn die Form der Nutzlast festgelegt ist, basierend auf dem Eigenschaftsnamen (z. B. halten alle Eigenschaften namens registry Map-Objekte).

Ungltiges JSON

Wenn JSON.parse einen String erhlt, der nicht der JSON-Grammatik entspricht, wird eine SyntaxError-Ausnahme ausgelst.

Arrays und Objekte drfen in JSON keine nachgestellten Kommata haben:

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-Strings mssen durch doppelte (nicht einfache) Anfhrungszeichen begrenzt werden:

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 in einem JavaScript-Stringliteral schreiben, sollten Sie entweder einfache Anfhrungszeichen verwenden, um das JavaScript-Stringliteral zu begrenzen, oder die doppelten Anfhrungszeichen, die das JSON-String begrenzen, maskieren:

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

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill des modernen JSON.parse-Verhaltens (context-Parameter des Revivers) in core-js
• JSON.stringify()