Detaillierte Erklärung der Verwendung von JSON.parse und JSON.stringify

Das JSON-Format (abgekürzt als JavaScript Object Notation) ist ein einfach zu schreibendes Textformat für den Datenaustausch.

Basierend auf der nativen JavaScript-Syntax kann es Objekte, Arrays, Zahlen, Zeichenfolgen, Boolesche Werte und Null serialisieren.

In ES5 wurde ein JSON-Objekt hinzugefügt, das speziell zur Verarbeitung von Daten im JSON-Format verwendet wird.

JSON ist ein Objekt, hat aber nur zwei Methoden: parse und stringify . Es kann nicht als Konstruktor verwendet werden und hat keine Attribute.

 Typ von JSON === 'Objekt'

JSON.parse

JSON.parse() wird verwendet, um eine JSON-Zeichenfolge zu analysieren und den entsprechenden JavaScript-Wert oder das entsprechende JavaScript-Objekt zu erhalten.

 JSON.parse('{}') // {}
JSON.parse('true') // wahr
JSON.parse('null') // null

JSON.parse-Syntax

 JSON.parse(Text[, Wiederbelebung])

• Text: Die zu analysierende Zeichenfolge.

  Wird eine Zahl übergeben, wird diese in eine Dezimalzahl umgewandelt und ausgegeben.

  Wird ein Boolescher Wert übergeben, wird dieser direkt ausgegeben.

  Wenn null übergeben wird, wird null ausgegeben.

  Andere Wertetypen werden nicht unterstützt, andernfalls wird ein Fehler gemeldet.

• Reviver: Optional, ein Konverter, der verwendet werden kann, um den durch das Parsen generierten Originalwert zu ändern.

Rückgabewert: JavaScript-Objekt/-Wert, entsprechend dem Objekt/Wert des angegebenen JSON-Textes.

Reviver-Parameter

Die Reviver-Funktion wird verwendet, um den analysierten JavaScript-Wert zu konvertieren und zu verarbeiten und nach der Verarbeitung das Endergebnis zurückzugeben.

Konvertierungsprozess:

• Der analysierte Wert selbst und alle darin enthaltenen Attribute werden in einer bestimmten Durchlaufreihenfolge aufgerufen. Die Reviver-Funktion wird als die beiden Parameter key und value übergeben.

  Durchlaufreihenfolge: Durchlauf gemäß der Hierarchie von innen nach außen und Erreichen der obersten Ebene, die der analysierte Wert selbst ist.

• Wenn reviver „undefined“ zurückgibt, wird das Objekt gelöscht. Wenn es einen anderen Wert zurückgibt, wird dieser Wert zum neuen Wert der aktuellen Eigenschaft.
• Beim Durchlaufen der obersten Ebene ist der Parameterschlüssel eine leere Zeichenfolge '' und der Parameterwert der aktuell analysierte Wert, da keine Attribute vorhanden sind.

Für die beiden Parameter key und value der Reviver-Funktion gelten unterschiedliche Datentypen:

• Grundlegende Werttypen Daten (String, Zahl, Boolean) und Null sowie leere Objekte {} und leere Arrays [] :

  Dann ist der Schlüssel eine leere Zeichenfolge und der Wert der entsprechende analysierte Wert.

  Da es sich bereits um die oberste Ebene handelt, verfügt es über keine weiteren Attribute.

• Objekt:

  Dann sind sowohl Schlüssel als auch Wert vorhanden, die jeweils dem Attributnamen und -wert entsprechen.

  Die oberste Ebene gibt einen Wert zurück, bei dem der Parameterschlüssel leer ist.

• Anordnung:

  Der Schlüssel entspricht dem Array-Index und der Wert entspricht dem Elementwert.

  Die oberste Ebene gibt einen Wert zurück, bei dem der Parameterschlüssel leer ist.

Grundlegende Typkonvertierung:

 JSON.parse('5', Funktion (Schlüssel, Wert) {
  console.log(`Schlüssel:${Schlüssel}, Wert:${Wert}`)
})
// Schlüssel:, Wert: 5
JSON.parse('null', Funktion (Schlüssel, Wert) {
  console.log(`Schlüssel:${Schlüssel}, Wert:${Wert}`)
})
// Schlüssel:, Wert: null
JSON.parse('{}', Funktion (Schlüssel, Wert) {
  console.log(`Schlüssel:${Schlüssel}, Wert:`, Wert)
})
// Schlüssel:, Wert:{}

Objektobjekte und Arrays:

 JSON.parse('[1, 2]', Funktion (Schlüssel, Wert) {
  console.log(`Schlüssel:${Schlüssel}, Wert:`, Wert)
})
// Schlüssel: 0, Wert: 1
// Schlüssel: 1, Wert: 2
// Schlüssel:, Wert: (2) [leer × 2]

JSON.parse('{ "Benutzer": "Benutzername", "Info": { "Alter": 25, "Geschlecht": 1 } }', Funktion (Schlüssel, Wert) {
  console.log(`Schlüssel:${Schlüssel}, Wert::`, Wert)
})
// Schlüssel: Benutzer, Wert: Zhang San// Schlüssel: Alter, Wert: 25
// Schlüssel:Geschlecht, Wert::1
// Schlüssel:Info, Wert:: {}
// Schlüssel:, Wert:: {}

Datenverarbeitung:

 JSON.parse('[1, 2]', Funktion (Schlüssel, Wert) {
  wenn(Schlüssel === '') {
    Rückgabewert
  }
  Rückgabewert + 3
})
// [4, 5]

JSON.parse-Funktionen

Beim Parsen eines JSON-Strings müssen einige Besonderheiten des JSON-Formats beachtet werden, da es sonst leicht zu Fehlern kommen kann.

Für JSON-Daten gelten strenge Vorschriften hinsichtlich des Typs und Formats der Werte. Die spezifischen Regeln lauten wie folgt:

• Diese Methode verwendet Daten im JSON-Format vom Typ „String“.

  Diese Methode unterstützt auch drei Arten von Werten: Zahlen, Boolesche Werte und Null und konvertiert sie in entsprechende Literalwerte.

  Andere Typen werden nicht unterstützt.

 JSON.parse('"Abkürzung"')
// 'China'
JSON.parse(null) // null
JSON.parse(111.) // 111
JSON.parse(0x12) // 18
JSON.parse(true) // wahr
JSON.parse([])
// Nicht abgefangener Syntaxfehler: Unerwartetes Ende der JSON-Eingabe

• Zeichenfolgen müssen in doppelte Anführungszeichen gesetzt werden, nicht in einfache Anführungszeichen.

 JSON.parse('"Zeichenfolge"')
// 'Zeichenfolge'
JSON.parse('\'Zeichenfolge\'')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token ' in JSON an Position 0

• Es werden nur Dezimalzeichenfolgen unterstützt, aber auf das Dezimalzeichen muss eine Zahl folgen.

 JSON.parse('111') // 111
JSON.parse('0x12')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token x in JSON an Position 1
JSON.parse('111.232') // 111.232
JSON.parse('111.')
// Nicht abgefangener Syntaxfehler: Unerwartetes Ende der JSON-Eingabe

• Undefiniert, Symbol und BigInt können nicht verwendet werden. Zahlen unterstützen NaN, Infinity und -Infinity nicht und es werden Fehler gemeldet.

 JSON.parse (undefiniert)
// Nicht abgefangener Syntaxfehler: Unerwartetes Token u in JSON an Position 0
JSON.parse(Symbol())
// Nicht abgefangener TypeError: Ein Symbolwert kann nicht in einen String konvertiert werden.
JSON.parse('12n')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token n in JSON an Position 2

• Zusammengesetzte Typen können nur Literale wie [] und {} sein.

  Der Objektkonstruktor kann nicht verwendet werden, da er als Ausführungsanweisung behandelt wird und nicht unterstützt wird.

  Objekte und Arrays können nicht verwendet werden und Funktionen, RegExp-Objekte, Datumsobjekte, Fehlerobjekte usw. sind nicht zulässig.

 JSON.parse('[]')
// []
JSON.parse('Objekt()')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token O in JSON an Position 0

• Objektattributnamen müssen in doppelte Anführungszeichen eingeschlossen werden.

 JSON.parse('{"Schlüssel": 1 }')
// {Schlüssel: 1}
JSON.parse('{Schlüssel: 1 }')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token k in JSON an Position 1

• Nach dem letzten Mitglied eines Arrays oder Objekts kann kein Komma gesetzt werden.

 JSON.parse('[1, 2, 3, 4, ]')
// VM2771:1 Nicht abgefangener Syntaxfehler: Unerwartetes Token ] in JSON an Position 13
JSON.parse('{"Schlüssel" : 1, }')
// VM2779:1 Nicht abgefangener Syntaxfehler: Unerwartetes Token } in JSON an Position 12

• Unterstützt Unicode-Escapes.

 JSON.parse('{"\u0066":333}')
// {f: 333}

• Einige Steuerzeichen und Escape-Zeichen werden nicht unterstützt, beispielsweise „\n“ und „\t“.

 JSON.parse('"\n"')
// Nicht abgefangener Syntaxfehler: Unerwartetes Token 

Andere Analysemethoden

Um einen JSON-String in ein JSON-Objekt (JS-Objektwert) umzuwandeln, können Sie auch andere Methoden verwenden, es handelt sich dabei jedoch nicht um sichere Codes.

 const str = '{"name":"json","alter":18}'
  const json = JSON.parse(str)
  const json = eval("(" + str + ")")
  const json = (neue Funktion("return " + str))()

JSON.stringify

JSON.stringify() konvertiert ein JavaScript-Objekt oder einen Wert in eine JSON-formatierte Zeichenfolge.

JSON.stringify-Syntax

 JSON.stringify(Wert[, Ersetzer [, Leerzeichen]])

• Wert: Das JavaScript-Objekt oder der Wert, der in eine JSON-Zeichenfolge serialisiert werden soll.
• replacer Optional, wird verwendet, um den zu serialisierenden Wert zu verarbeiten.
• Das Leerzeichen ist optional und gibt eine leere Zeichenfolge für die Einrückung an, die zum Verschönern der Ausgabe verwendet wird.

Rückgabewert: Eine JSON-formatierte Zeichenfolge, die den angegebenen Wert darstellt.

replacer-Parameter

Der Ersetzungsparameter kann eine der folgenden drei Situationen aufweisen:

• Wenn es null, undefiniert oder von anderem Typ ist, wird es ignoriert und nicht verarbeitet.

 JSON.stringify({key: 'json'}, null, null) // '{"key":"json"}'
JSON.stringify({Schlüssel: 'json'}, true) // '{"Schlüssel":"json"}'

• Wenn es sich um ein Array handelt, werden nur die in diesem Array enthaltenen Attributnamen in die Ergebniszeichenfolge serialisiert.

  Nur gültig für Objekteigenschaften, nicht für Arrays.

 const obj = {
  json: "JSON",
  analysieren: 'PARSE',
  stringify: 'STRINGIFY'
}
JSON.stringify(Objekt, ['parsen', 'stringify'])
// '{"parse":"PARSE","stringify":"STRINGIFY"}'

• Wenn es sich um eine Funktion handelt, wird jedes Attribut des serialisierten Werts von der Funktion transformiert und verarbeitet.

Verarbeitungsprozess:

• Die Funktion hat zwei Parameter, den Attributnamen (Schlüssel) und den Attributwert (Wert), die beide serialisiert werden.
• Beim ersten Aufruf ist der Schlüssel eine leere Zeichenfolge und der Wert das gesamte zu serialisierende Objekt.
• Bei der zweiten Verarbeitung wird das Ergebnis der ersten Verarbeitung übernommen, jede weitere Verarbeitung erhält das Ergebnis der vorherigen Verarbeitung.
• Anschließend werden die einzelnen Attributnamen und Attributwerte der Reihe nach verarbeitet und nach Abschluss zurückgegeben.

 JSON.stringify({ json: 1, stringify: { val: 'rr'} }, (Schlüssel, Wert) => {
  console.log(`Schlüssel: ${key}, Wert:`, Wert)
  Rückgabewert
}) 
// Schlüssel: ，Wert: {json: 1, stringify: {…}}
// Schlüssel: json, Wert: 1
// Schlüssel: stringify, Wert: {val: 'rr'}
// Schlüssel: val, Wert: rr
// '{"json":1,"stringify":{"val":"rr"}}'

Typverarbeitung des Wertes:

• Wenn ein String, eine Zahl, ein Boolescher Wert oder Null vom primitiven Typ zurückgegeben wird, wird dieser direkt zum serialisierten JSON-String hinzugefügt.
• Wenn andere Objekte zurückgegeben werden, werden die Eigenschaften des Objekts später der Reihe nach serialisiert. Wenn es sich um eine Funktion handelt, wird keine Verarbeitung durchgeführt.
• Wenn dies „true“ oder „undefined“ zurückgibt, wird die Eigenschaft nicht ausgegeben.
• Wenn beim Serialisieren eines Arrays der Wert „undefiniert“ oder eine Funktion zurückgibt, wird er durch „null“ ersetzt.

 JSON.stringify({ json: 1, stringify: 'rr' }, (Schlüssel, Wert) => {
  wenn (Typ des Wertes === 'Zahl') {
    gib 'ss' zurück
  }
  Rückgabewert
}) 
// '{"json":"ss","stringify":"rr"}'

JSON.stringify({ json: 1, stringify: 'rr' }, (Schlüssel, Wert) => {
  wenn (Typ des Wertes === 'Zahl') {
    Wert = undefiniert
  }
  Rückgabewert
}) 
// '{"stringify":"rr"}'

Das folgende Beispiel zeigt, wie ein Objektwert zurückgegeben wird:

 JSON.stringify({ json: 1, stringify: 'rr' }, (Schlüssel, Wert) => {
  if (typeof value === 'object') { // Wenn das gesamte Objekt zum ersten Mal zurückgegeben wird, ist der Typ „Object“
    Rückgabewert { parse: 'dd' }
  }
  Rückgabewert
}) 
'{"parse":"dd"}'

Raumparameter

Der Leerzeichenparameter wird verwendet, um den Abstand in der Ergebniszeichenfolge zu steuern und die Ausgabe zu verschönern. Zur Eingabe stehen drei mögliche Werte zur Verfügung:

• Handelt es sich um eine Zahl, wird bei der Serialisierung jede Ebene um mehr Leerzeichen eingerückt, die dem Zahlenwert entsprechen, als die vorherige Ebene, und zwar im Bereich von 1 bis 10, also mindestens 1 und höchstens 10 Leerzeichen.
• Handelt es sich um eine Zeichenfolge, wird sie bei der Serialisierung an den Anfang jeder Zeile gesetzt und jede Ebene wird bis zu einer maximalen Anzahl von Zeichen weiter eingerückt als die vorherige Ebene. Wird diese Anzahl überschritten, wird die Zeichenfolge abgeschnitten.
• Wenn es null, undefiniert oder von anderem Typ ist, wird es ignoriert und nicht verarbeitet.

 JSON.stringify({Schlüssel: 'json'}, null, 2)
// '{\n "Schlüssel": "json"\n}'
JSON.stringify({Schlüssel: 'json', Liste: { str: 'str' } }, null, '|-')
// '{\n|-"Schlüssel": "json",\n|-"Liste": {\n|-|-"str": "str"\n|-}\n}'
JSON.stringify({Schlüssel: 'json'}, null, null)
// '{"Schlüssel":"json"}'

JSON.stringify-Funktion

• Grundlegende Typwerte wie Zeichenfolge, Zahl, Boolescher Wert sowie Zeichenfolgen-, Boolesche und Zahlenobjektwerte werden für die Ausgabe in Zeichenfolgen mit primitiven Werten konvertiert.

 JSON.stringify(333) // '333'
JSON.stringify(true) // 'wahr'
JSON.stringify(neuer String('333')) //'"333"'
JSON.stringify(Boolean(true)) // 'wahr'

• Bei grundlegenden Zeichenfolgentypen wird das Konvertierungsergebnis in Anführungszeichen eingeschlossen.

  Denn beim Wiederherstellen weisen die Anführungszeichen JavaScript darauf hin, dass es sich um eine Zeichenfolge und nicht um eine Variable handelt.

 JSON.stringify('json') === 'json' // falsch
JSON.stringify('json') === '"json"' // wahr

• undefiniert, Funktionen, Symbole und XML-Objekte:

• Wenn es in einem Object-Objekt erscheint, wird es ignoriert;
• Wenn es in einem Array erscheint, wird es als null serialisiert;
• Wenn es allein verwendet wird, gibt es „undefined“ zurück.

 JSON.stringify(Symbol()) // undefiniert
JSON.stringify([Symbol(), Math.abs, undefiniert]) // '[null,null,null]'
JSON.stringify({ [Symbol()]: Math.abs, Schlüssel: nicht definiert }) // '{}'

• Werte wie NaN, Infinity und -Infinity sowie null werden als null serialisiert.

 JSON.stringify(null) // 'null'
JSON.stringify(NaN) // 'null'

• Objektobjekte sowie Objekte vom zusammengesetzten Typ wie Map/Set/WeakMap/WeakSet ignorieren die nicht durchquerbaren Eigenschaften der Objekte während der Serialisierung.

 const obj = {}
Objekt.defineProperties(obj, {
  'json': { Wert: 'JSON', aufzählbar: true },
  'stringify': { Wert: 'STRINGIFY', aufzählbar: false }
})
JSON.stringify(Objekt)
// '{"json":"JSON"}'

• Attribute mit dem Symbol als Namen werden ignoriert.

 JSON.stringify({[Symbol()]: 333}) // '{}'

• Außer bei Arrays können auch die Eigenschaften anderer Objekte bei der Serialisierung in der falschen Reihenfolge sein.

 const a = { '1': 911, 'r': 822, '11': 9922}
JSON.stringify(a)
// '{"1":911,"11":9922,"r":822}'

• Wenn das konvertierte Objekt toJSON() Methode definiert, ist der Rückgabewert dieser Methode das Serialisierungsergebnis des konvertierten Objekts.

  Andere Attribute werden vom Prozess ignoriert.

 const a = { Schlüssel: 'json' }
a.toJSON = () => 'JSON'
JSON.stringify(a)
// '"JSON"'

• RegExp-Objekte und Fehlerobjekte werden als leere Objektzeichenfolgen serialisiert.

 JSON.stringify(/\d/) // "{}"
JSON.stringify(neuer Fehler()) // "{}"

Wenn Sie das entsprechende Objekt serialisieren möchten, müssen Sie die Methode toJSON festlegen und implementieren.

 RegExp.prototype.toJSON = RegExp.prototype.toString
JSON.stringify(/\d/) // '"/\\\\d/"'

• Für das Date-Objekt ist toJSON() definiert, wodurch es in einen String konvertiert wird, sodass es serialisiert werden kann.

  Dasselbe wie Date.toISOString() .

 JSON.stringify(neues Datum())
// '"2021-12-31T02:24:05.477Z"'

• Die Ausführung dieser Methode auf einem Objekt mit Zirkelreferenz führt zu einem Fehler.

  Objekte verweisen aufeinander und bilden eine Endlosschleife.

 const a = {}
ein.Schlüssel = ein
JSON.stringify(a)
// Nicht abgefangener TypeError: Konvertierung der kreisförmigen Struktur in JSON

• Das Konvertieren eines BigInt-Wertes löst einen TypeError aus.

  BigInt-Wert kann nicht JSON-serialisiert werden

 JSON.stringify(12n)
// Nicht abgefangener TypeError: Ich weiß nicht, wie man einen BigInt serialisiert

• Bessere Unterstützung für Unicode-Escapes

 const a = {'\u0066': 333}
JSON.stringify(a)
// '{"f":333}'

Damit ist dieser Artikel zur detaillierten Verwendung von JSON.parse und JSON.stringify abgeschlossen. Ich hoffe, dass es für jedermanns Studium hilfreich sein wird, und ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.