JSON speichert Daten als Nur-Text. Seine Grammatik ist eine Teilmenge der Grammatik von JavaScript-Ausdrücken. Zum Beispiel:

{
    "first": "Jane",
    "last": "Porter",
    "married": true,
    "born": 1890,
    "friends": [ "Tarzan", "Cheeta" ]
}

JSON verwendet die folgenden Konstrukte aus JavaScript-Ausdrücken

Es hält sich an diese Regeln

Douglas Crockford entdeckte JSON im Jahr 2001. Er gab ihm einen Namen und erstellte eine Spezifikation unter http://json.org

Anfangs wollte Crockford, dass JSON den Namen JavaScript Markup Language hat, aber das Akronym JSML war bereits von der JSpeech Markup Language belegt.

Die JSON-Spezifikation wurde in viele menschliche Sprachen übersetzt, und es gibt jetzt Bibliotheken für viele Programmiersprachen, die das Parsen und Generieren von JSON unterstützen.

Douglas Crockford erstellte eine JSON-Visitenkarte mit einem Logo auf der Vorderseite (siehe Abbildung 22-1) und der vollständigen Grammatik auf der Rückseite (siehe Abbildung 22-2). Das macht visuell deutlich, wie positiv einfach JSON ist.

Abbildung 22-1. Die Vorderseite der JSON-Visitenkarte zeigt ein Logo (Quelle: Eric Miraglia).

Abbildung 22-2. Die Rückseite der JSON-Visitenkarte enthält die vollständige Grammatik (Quelle: Eric Miraglia).

Die Grammatik kann wie folgt transkribiert werden

Die globale Variable JSON dient als Namespace für Funktionen, die Strings mit JSON-Daten erzeugen und parsen.

In Objekten berücksichtigt JSON.stringify() nur aufzählbare eigene Eigenschaften (siehe Eigenschaftenattribute und Eigenschaftsdeskriptoren). Das folgende Beispiel zeigt, dass die nicht aufzählbare eigene Eigenschaft obj.foo ignoriert wird:

> var obj = Object.defineProperty({}, 'foo', { enumerable: false, value: 7 });
> Object.getOwnPropertyNames(obj)
[ 'foo' ]
> obj.foo
7
> JSON.stringify(obj)
'{}'

Wie JSON.stringify() Werte behandelt, die von JSON nicht unterstützt werden (wie Funktionen und undefined), hängt davon ab, wo es sie findet. Ein nicht unterstützter Wert selbst führt dazu, dass stringify() undefined anstelle eines Strings zurückgibt

> JSON.stringify(function () {})
undefined

Eigenschaften, deren Werte nicht unterstützt werden, werden einfach ignoriert

> JSON.stringify({ foo: function () {} })
'{}'

Nicht unterstützte Werte in Arrays werden als nulls stringifiziert

> JSON.stringify([ function () {} ])
'[null]'

Wenn JSON.stringify() auf ein Objekt trifft, das eine toJSON-Methode hat, verwendet es diese Methode, um einen zu stringifizierenden Wert zu erhalten. Zum Beispiel:

> JSON.stringify({ toJSON: function () { return 'Cool' } })
'"Cool"'

Daten haben bereits eine toJSON-Methode , die einen ISO 8601-Datumsstring erzeugt:

> JSON.stringify(new Date('2011-07-29'))
'"2011-07-28T22:00:00.000Z"'

Die vollständige Signatur einer toJSON-Methode lautet wie folgt

function (key)

Der key-Parameter ermöglicht es Ihnen, je nach Kontext unterschiedlich zu stringifizieren. Es ist immer ein String und gibt an, wo Ihr Objekt im Elternobjekt gefunden wurde

Ich werde toJSON() anhand des folgenden Objekts demonstrieren

var obj = {
    toJSON: function (key) {
        // Use JSON.stringify for nicer-looking output
        console.log(JSON.stringify(key));
        return 0;
    }
};

Wenn Sie JSON.stringify() verwenden, wird jedes Vorkommen von obj durch 0 ersetzt. Die toJSON()-Methode wird darüber informiert, dass obj am Eigenschaftsschlüssel 'foo' und am Array-Index 0 angetroffen wurde

> JSON.stringify({ foo: obj, bar: [ obj ]})
"foo"
"0"
'{"foo":0,"bar":[0]}'

Die integrierten toJSON()-Methoden sind wie folgt:

Der spezielle Wurzelknoten kommt zuerst, in einer Präfix-Iteration (Elternteil vor Kindern). Der erste besuchte Knoten ist immer die Pseudowurzel. Die letzte Zeile, die nach jedem Aufruf angezeigt wird, ist der von stringify() zurückgegebene String:

> JSON.stringify(['a','b'], nodeVisitor)
{"":["a","b"]} # "" # ["a","b"]
["a","b"] # "0" # "a"
["a","b"] # "1" # "b"
'["a","b"]'

> JSON.stringify({a:1, b:2}, nodeVisitor)
{"":{"a":1,"b":2}} # "" # {"a":1,"b":2}
{"a":1,"b":2} # "a" # 1
{"a":1,"b":2} # "b" # 2
'{"a":1,"b":2}'

> JSON.stringify('abc', nodeVisitor)
{"":"abc"} # "" # "abc"
'"abc"'

Die Blätter kommen zuerst, in einer Postfix-Iteration (Kinder vor Elternteil). Der zuletzt besuchte Knoten ist immer die Pseudowurzel. Die letzte Zeile, die nach jedem Aufruf angezeigt wird, ist der von parse() zurückgegebene JavaScript-Wert:

> JSON.parse('["a","b"]', nodeVisitor)
["a","b"] # "0" # "a"
["a","b"] # "1" # "b"
{"":["a","b"]} # "" # ["a","b"]
[ 'a', 'b' ]

> JSON.parse('{"a":1, "b":2}', nodeVisitor)
{"a":1,"b":2} # "a" # 1
{"a":1,"b":2} # "b" # 2
{"":{"a":1,"b":2}} # "" # {"a":1,"b":2}
{ a: 1, b: 2 }

> JSON.parse('"hello"', nodeVisitor)
{"":"hello"} # "" # "hello"
'hello'