JSON.parse()

text

Der String, der als JSON geparst werden soll. Siehe das JSON-Objekt für eine Beschreibung der JSON-Syntax.

reviver Optional

Wenn eine Funktion angegeben ist, definiert diese, wie jeder Wert, der ursprünglich durch das Parsen erzeugt wird, vor der Rückgabe transformiert wird. Nicht aufrufbare Werte werden ignoriert. Die Funktion wird mit den folgenden Argumenten aufgerufen:

key

Der Schlüssel, der dem Wert zugeordnet ist.

value

Der durch das Parsen erzeugte Wert.

context Optional

Ein Kontextobjekt, das den Zustand enthält, der für den aktuellen Ausdruck relevant ist, der wiederhergestellt wird. Es ist ein neues Objekt für jeden Aufruf der Reviver-Funktion. Es wird nur beim Wiederherstellen von primitiven Werten übergeben, aber nicht, wenn value ein Objekt oder Array ist. Es enthält die folgende Eigenschaft:

source

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

Das entsprechende Object, Array, der String, die Nummer, der boolesche Wert oder der null-Wert zur angegebenen JSON text.

SyntaxError

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

JSON.parse() analysiert einen JSON-String gemäß der JSON-Grammatik und bewertet den String, als wäre es ein JavaScript-Ausdruck. Der einzige Fall, in dem ein Stück JSON-Text einen anderen Wert als der gleiche JavaScript-Ausdruck darstellt, ist beim Umgang mit dem Schlüssel "__proto__" — siehe Objektliteral-Syntax vs. JSON.

Wenn ein reviver angegeben ist, wird der durch das Parsen berechnete Wert transformiert, bevor er zurückgegeben wird. Genau gesagt, laufen der berechnete Wert und alle seine Eigenschaften (in einer Tiefensuche-Reihenfolge, beginnend mit den am tiefsten geschachtelten Eigenschaften und fortfahrend bis zum ursprünglichen Wert selbst) einzeln durch den reviver.

Der reviver wird mit dem Objekt, das die verarbeitete Eigenschaft enthält, als this aufgerufen (es sei denn, Sie definieren den reviver als Pfeilfunktion, in diesem Fall gibt es keine separate this-Bindung) und zwei Argumenten: key und value, die den Eigenschaftsnamen als String (auch für Arrays) und den Eigenschaftswert darstellen. Für primitive Werte wird ein zusätzlicher context-Parameter übergeben, der den Quelltext dieses Wertes enthält. Wenn die reviver-Funktion undefined zurückgibt (oder keinen Wert zurückgibt — z.B. wenn die Ausführung am Ende der Funktion endet), wird die Eigenschaft aus dem Objekt gelöscht. Andernfalls wird die Eigenschaft neu definiert, um den zurückgegebenen Wert zu sein. Wenn der reviver nur einige Werte transformiert und andere nicht, müssen Sie sicherstellen, dass alle nicht transformierten Werte unverändert zurückgegeben werden — andernfalls werden sie aus dem resultierenden Objekt gelöscht.

Ähnlich wie der replacer-Parameter von JSON.stringify(), wird bei Arrays und Objekten der reviver zuletzt auf den Wurzelwert mit einem leeren String als key und dem Wurzelobjekt als value aufgerufen. Für andere gültige JSON-Werte funktioniert der reviver ähnlich und wird einmal mit einem leeren String als key und dem Wert selbst als value aufgerufen.

Wenn Sie einen anderen Wert als reviver zurückgeben, wird dieser Wert den ursprünglich geparsten Wert vollständig ersetzen. Dies gilt sogar für den Wurzelwert. Zum Beispiel:

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

console.log(transformedObj1); // undefined

Es gibt keine Möglichkeit, dies allgemein zu umgehen. Sie können den Fall, in dem der key ein leerer String ist, nicht speziell behandeln, da JSON-Objekte auch Schlüssel mit leeren Strings enthalten können. Sie müssen sehr genau wissen, welche Art von Transformation für jeden Schlüssel bei der Implementierung des Revivers erforderlich ist.

Beachten Sie, dass der reviver ausgeführt wird, nachdem der Wert geparst wurde. Beispielsweise werden Zahlen im JSON-Text bereits in JavaScript-Zahlen umgewandelt und können dabei an Genauigkeit verlieren. Eine Möglichkeit, große Zahlen ohne Genauigkeitsverlust zu übertragen, besteht darin, sie als Strings zu serialisieren und sie in BigInts oder andere geeignete beliebige Präzisionsformate wiederherzustellen.

Sie können auch die Eigenschaft context.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;
});

Damit ein Wert ordnungsgemäß zurückgegeben wird (d.h. er wird in das ursprüngliche Objekt deserialisiert), muss der Serialisierungsprozess die Typinformationen bewahren. Zum Beispiel können Sie den replacer-Parameter von JSON.stringify() zu diesem Zweck 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 keine syntaktische Möglichkeit bietet, Typ-Metadaten zu annotieren, müssen Sie eine der folgenden Methoden berücksichtigen, um Werte wiederherzustellen, die keine einfachen Objekte sind:

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

Wenn JSON.parse einen String erhält, der nicht der JSON-Grammatik entspricht, wirft es einen SyntaxError.

Arrays und Objekte dürfen im JSON keine abgeschlossenen 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 müssen durch doppelte (nicht einfache) Anführungszeichen begrenzt sein:

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-Stringliterals schreiben, sollten Sie entweder einfache Anführungszeichen verwenden, um den JavaScript-Stringliteral zu begrenzen, oder die doppelten Anführungszeichen maskieren, die den JSON-String begrenzen:

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

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