Die statische MethodeJSON.parse() analysiert einen JSON-String und konstruiert den durch den String beschriebenen JavaScript-Wert oder das Objekt. Es kann eine optionalereviver-Funktion bereitgestellt werden, um eine Transformation des resultierenden Objekts durchzuführen, bevor es zurückgegeben wird.

Probieren Sie es aus

const json = '{"result":true, "count":42}';const obj = JSON.parse(json);console.log(obj.count);// Expected output: 42console.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 dasJSON-Objekt für eine Beschreibung der JSON-Syntax.

reviverOptional

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

key

Der Schlüssel, der mit dem Wert verknüpft ist.

value

Der durch das Parsen erzeugte Wert.

contextOptional

Ein Kontextobjekt, das den Status enthält, der für den aktuellen Ausdruck relevant ist, der wiederbelebt wird. Es ist ein neues Objekt für jeden Aufruf der Reviver-Funktion. Es wird nur beim Wiederbeleben primitiver Werte übergeben, jedoch nicht, wennvalue ein Objekt oder Array ist. Es enthält folgende Eigenschaft:

source

Der ursprüngliche JSON-String, der diesen Wert darstellt.

Rückgabewert

DerObject,Array, String, die Zahl, der Boolean oder dernull-Wert, der dem gegebenen JSON-text entspricht.

Ausnahmen

SyntaxError

Wird ausgelöst, wenn der zu parsende String kein gültiges JSON ist.

Beschreibung

JSON.parse() analysiert einen JSON-String entsprechend derJSON-Grammatik und bewertet den String, als ob er ein JavaScript-Ausdruck wäre. Der einzige Fall, in dem ein JSON-Text einen anderen Wert darstellt als der gleiche JavaScript-Ausdruck, tritt bei dem Schlüssel"__proto__" auf — sieheObjektliteral-Syntax vs. JSON.

Der Reviver-Parameter

Wenn einreviver angegeben ist, wird der durch das Parsen berechnete Werttransformiert, bevor er zurückgegeben wird. Insbesondere werden der berechnete Wert und alle seine Eigenschaften (in einerTiefensuche beginnend mit den am tiefsten verschachtelten Eigenschaften weiter zur ursprünglichen Wert selbst) einzeln durch denreviver geführt.

Derreviver wird mit dem Objekt aufgerufen, das die zu verarbeitende Eigenschaft enthält, alsthis (es sei denn, Sie definieren denreviver als Arrow-Funktion, in diesem Fall gibt es keine separatethis-Bindung) und zwei Argumenten:key undvalue, die den Eigenschaftsnamen als String (auch für Arrays) und den Eigenschaftswert darstellen. Für primitive Werte wird ein zusätzlichercontext-Parameter übergeben, der den Quelltext dieses Wertes enthält. Wenn diereviver-Funktionundefined zurückgibt (oder keinen Wert zurückgibt — zum Beispiel, wenn die Ausführung am Ende der Funktion endet), wird die Eigenschaft aus dem Objekt gelöscht. Andernfalls wird die Eigenschaft neu definiert, um der Rückgabewert zu sein. Wenn derreviver nur einige Werte transformiert und andere nicht, sollten alle untransformierten Werte unverändert zurückgegeben werden — andernfalls werden sie aus dem resultierenden Objekt gelöscht.

Ähnlich wie beimreplacer-Parameter vonJSON.stringify() wirdreviver bei Arrays und Objekten zuletzt auf den Wurzelwert mit einem leeren String alskey und dem Wurzelobjekt alsvalue aufgerufen. Für andere gültige JSON-Werte funktioniertreviver ähnlich und wird einmal mit einem leeren String alskey und dem Wert selbst alsvalue aufgerufen.

Wenn Sie einen anderen Wert vonreviver zurückgeben, ersetzt dieser Wert den ursprünglich geparsten Wert vollständig. Dies gilt auch für 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 Möglichkeit, dies zu umgehen. Sie können den Fall, bei demkey ein leerer String ist, nicht speziell behandeln, da JSON-Objekte auch Schlüssel haben können, die leere Strings sind. Sie müssen sehr genau wissen, welche Art von Transformation für jeden Schlüssel erforderlich ist, wenn Sie den Reviver implementieren.

Beachten Sie, dassreviver ausgeführt wird, nachdem der Wert geparst wurde. So werden beispielsweise Zahlen im JSON-Text bereits in JavaScript-Zahlen konvertiert und können dabei an Genauigkeit verlieren. Eine Möglichkeit, große Zahlen ohne Genauigkeitsverlust zu übertragen, ist, sie als Strings zu serialisieren und sie inBigInts oder andere geeignete Formate mit beliebiger Genauigkeit wiederzubeleben.

Sie können auch die Eigenschaftcontext.source verwenden, um auf den ursprünglichen 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"); // trueJSON.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 ursprüngliche Objekt deserialisiert), muss der Serialisierungsprozess die Typinformationen beibehalten. Beispielsweise können Sie hierfür denreplacer-Parameter vonJSON.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, müssen Sie eine der folgenden Möglichkeiten 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 namensregistryMap-Objekte).

Ungültiges JSON

WennJSON.parse einen String erhält, der nicht der JSON-Grammatik entspricht, wird eineSyntaxError-Ausnahme ausgelöst.

Arrays und Objekte dürfen in JSON keinenachgestellten Kommata haben:

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

JSON-Strings müssen durch doppelte (nicht einfache) Anführungszeichen begrenzt werden:

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

Wenn Sie JSON in einem JavaScript-Stringliteral schreiben, sollten Sie entweder einfache Anführungszeichen verwenden, um das JavaScript-Stringliteral zu begrenzen, oder die doppelten Anführungszeichen, die das JSON-String begrenzen, maskieren:

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

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill des modernenJSON.parse-Verhaltens (context-Parameter des Revivers) incore-js
• JSON.stringify()