imported>Faisalhussain2008: Erkennt automatisch die Probleme im JSON-Code und behebt sie.

2026-05-01T05:14:19Z

Erkennt automatisch die Probleme im JSON-Code und behebt sie.

Neue Seite

{{Infobox Dateiformat
| Logo = [[Datei:JSON vector logo.svg]]
| MIME = application/json
| Dateiendung = .json
| Standard = <nowiki>RFC 8259</nowiki>,<ref name="RFC8259" /> ECMA-404<ref name="ECMA-404" />
| Website = https://json.org/
}}
Die '''JavaScript Object Notation''' ('''JSON''' [{{IPA|ˈdʒeɪsən}}]) ist ein kompaktes [[Datenformat]] in einer einfach lesbaren Textform für den [[Datenaustausch]] zwischen Anwendungen. JSON ist von Programmiersprachen unabhängig. [[Parser]] und Generatoren existieren in den meisten verbreiteten Sprachen.

JSON wurde ursprünglich 2001<ref>{{Internetquelle |url=https://www.youtube.com/watch?v=-C-JoyNuQJs |titel=Douglas Crockford: The JSON Saga (Talk bei Yahoo!) |sprache=en |abruf=2025-09-18}}</ref> von Douglas Crockford spezifiziert.<ref name="RFC7159" /> Derzeit (Stand Ende 2017) wird es durch zwei inhaltlich gleiche Standards spezifiziert – <nowiki>RFC 8259</nowiki><ref name="RFC8259" /> sowie ECMA-404.<ref name="ECMA-404" />

== Einsatzgebiete ==
JSON wird zur Übertragung und zum Speichern strukturierter Daten eingesetzt. Es dient als Datenformat bei der Datenübertragung ([[Serialisierung]]). Insbesondere bei [[Webanwendung]]en und [[Mobile App|mobilen Apps]] wird es in Verbindung mit [[JavaScript]], [[Ajax (Programmierung)|Ajax]] oder [[WebSocket]]s zum Übertragen von Daten zwischen dem Client und dem Server häufig genutzt.

== Datenstruktur und Formatdefinition ==
=== Zeichencodierung und Datentypen ===
Die Daten können beliebig verschachtelt werden, beispielsweise ist eine indizierte Liste (englisch „array“) von Objekten möglich, welche wiederum Arrays oder Objekte enthalten. Als [[Zeichenkodierung]] benutzt JSON standardmäßig [[UTF-8]]. Auch [[UTF-16]] und [[UTF-32]] sind möglich.

JSON kennt die folgenden Typen von ''Elementen''.
; [[Nullwert]]
: wird durch das Schlüsselwort '''<code>null</code>''' dargestellt.
; [[Boolesche Variable|Boolescher Wert]]
: wird durch die Schlüsselwörter '''<code>true</code>''' und '''<code>false</code>''' dargestellt. Dies sind ''keine'' Zeichenketten. Sie werden daher, wie '''<code>null</code>''', ''nicht'' in [[Anführungszeichen]] gesetzt.
; [[Zahl]]
: ist eine Folge der Ziffern '''<code>0</code>'''–'''<code>9</code>'''. Diese Folge kann durch ein [[Minuszeichen|negatives Vorzeichen]] '''<code>-</code>''' eingeleitet und durch einen [[Dezimalpunkt]] '''<code>.</code>''' unterbrochen sein. Die Zahl kann durch die Angabe eines Exponenten '''<code>e</code>''' oder '''<code>E</code>''' ergänzt werden, dem ein optionales [[Vorzeichen (Zahl)|Vorzeichen]] '''<code>+</code>''' oder '''<code>-</code>''' und eine Folge der Ziffern '''<code>0</code>'''–'''<code>9</code>''' folgt.
; [[Zeichenkette]]
: beginnt und endet mit doppelten geraden Anführungszeichen ('''<code>"</code>'''). Sie kann [[Unicode]]-Zeichen und durch '''<code>\</code>''' eingeleitete [[Escape-Sequenz]]en enthalten.
; [[Array (Datentyp)|Array]]
: beginnt mit '''<code>[</code>''' und endet mit '''<code>]</code>'''. Es enthält eine durch Kommata geteilte, indizierte Liste von ''Elementen'' gleichen oder verschiedenen Typs. Leere Arrays sind zulässig.

; [[Assoziatives Datenfeld|Objekt]]
: beginnt mit '''<code>{</code>''' und endet mit '''<code>}</code>'''. Es enthält eine durch Kommata geteilte, ungeordnete Liste von ''Eigenschaften''. Objekte ohne Eigenschaften („leere Objekte“) sind zulässig.
; Eigenschaft
: besteht aus einem Schlüssel und einem Wert, getrennt durch einen Doppelpunkt (<code>Schlüssel : Wert</code>). Die Schlüssel sollten eindeutig sein, da unterschiedliche Parser mit mehrfach vorkommenden Schlüsseln unterschiedlich umgehen. Während ECMA-404 keine Eindeutigkeit voraussetzt, fordert <nowiki>RFC 7159</nowiki>,<ref name="RFC7159" /> dass Schlüssel innerhalb eines Objekts eindeutig sind.
:* der '''Schlüssel''' ist eine ''Zeichenkette''.
:* der '''Wert''' ist ein beliebiges ''Element''.

Nicht signifikante [[Leerraum]]-Zeichen sind erlaubt, also Leerzeichen (Unicode U+0020), horizontale Tabs (U+0009), Zeilenumbrüche mittels LF und/oder CR (U+000A bzw. U+000D).<ref>{{RFC-Internet |Autor=Douglas Crockford |RFC=4627 |Titel=The application/json Media Type for JavaScript Object Notation (JSON) |Datum=2006-07 |Abschnitt=2 |Abschnittstitel=JSON Grammar}}</ref> Diese Zeichen werden außerhalb von Zeichenketten bei der Interpretation ignoriert.

== Einschränkungen ==
Im Gegensatz zu JavaScript und vielen anderen Programmiersprachen erlaubt JSON für Zahlen nicht die in [[IEEE 754]] definierten Sonderwerte für [[Unendlich (Mathematik)|Unendlich]] und [[NaN]].<ref name="RFC7159" /> Außerdem fehlen Wertetypen für zum Beispiel Datums- und Zeitwerte, [[Regulärer Ausdruck|reguläre Ausdrücke]], [[Anonyme Funktion|Funktionsliterale]] und [[Ausnahmebehandlung|Fehlertypen]].<ref name="RFC7159" /> Beim Serialisieren nach JSON können solche nicht abbildbaren Werte entweder durch <code>null</code> ersetzt werden, oder sie müssen auf andere Weise umgesetzt werden. Bei Datums- und Zeit-Werten ist beispielsweise die Konvertierung in eine Zeichenkette gemäß [[ISO 8601]] üblich.<ref>{{Internetquelle |url=https://docs.jsonata.org/date-time#json-and-iso-8601 |titel=Date/Time processing · JSONata |werk=docs.jsonata.org |sprache=en |abruf=2023-05-21}}</ref>

JSON unterstützt ebenfalls keine [[Kommentar (Programmierung)|Kommentare]], die beim Einlesen der Daten ignoriert werden würden.

Um diese Einschränkungen zu umgehen, erlauben viele JSON-[[Programmbibliothek]]en (optional) die Verletzung des JSON-Standards, womit beispielsweise Werte für Unendlich und NaN<ref>{{Internetquelle |url=https://fasterxml.github.io/jackson-core/javadoc/2.10/com/fasterxml/jackson/core/json/JsonReadFeature.html#ALLOW_NON_NUMERIC_NUMBERS |titel=JsonReadFeature (Jackson-core 2.10.0 API) |sprache=en |abruf=2023-05-21}}</ref> unterstützt werden können oder wodurch Kommentare ignoriert werden, statt zu Fehlern zu führen<ref>{{Internetquelle |url=https://fasterxml.github.io/jackson-core/javadoc/2.10/com/fasterxml/jackson/core/json/JsonReadFeature.html#ALLOW_JAVA_COMMENTS |titel=JsonReadFeature (Jackson-core 2.10.0 API) |sprache=en |abruf=2023-05-21}}</ref>.

== Beispiel ==
Ein Beispiel eines Kreditkartenkunden.
<syntaxhighlight lang="json">
{
"Herausgeber": "Xema",
"Nummer": "1234-5678-9012-3456",
"Deckung": 2e+6,
"Waehrung": "EURO",
"Inhaber":
{
"Name": "Mustermann",
"Vorname": "Max",
"Teilnahme am Bonusprogramm": true,
"Hobbys": ["Reiten", "Golfen", "Lesen"],
"Alter": 42,
"Kinder": [],
"Partner": null
}
}
</syntaxhighlight>

== JSON Schema ==
JSON Schema gibt ein JSON-basiertes Format an, um die Struktur von JSON-Daten für die [[Validierung (Informatik)|Validierung]], Dokumentation und Interaktionssteuerung zu definieren. Es enthält einen Vertrag für die JSON-Daten, die für eine bestimmte Anwendung erforderlich sind, und wie diese Daten geändert werden können.

JSON Schema basiert auf den Konzepten von [[XML Schema]] (XSD), ist jedoch JSON-basiert. Wie in XSD können dieselben Serialisierungs- und Deserialisierungsprogramme sowohl für das Schema als auch für die Daten verwendet werden. Es ist selbstbeschreibend und in einem Internet-Entwurf der [[Internet Engineering Task Force]] festgelegt. Für verschiedene [[Programmiersprache]]n stehen mehrere [[Validator]]en mit jeweils unterschiedlichen Konformitätsstufen zur Verfügung.<ref>{{Internetquelle |url=https://json-schema.org/ |titel=JSON Schema |sprache=en |abruf=2020-08-08}}</ref>

=== Beispiel ===
<syntaxhighlight lang="json">
{
"$schema": "http://json-schema.org/draft/2019-09/schema",
"title": "Politiker",
"type": "object",
"required": ["Vorname", "Nachname", "Geburtsdatum", "Nationalität"],
"properties":
{
"Vorname":
{
"type": "string"
},
"Nachname":
{
"type": "string"
},
"Geburtsdatum":
{
"type": "date"
},
"Nationalität":
{
"type": "string"
},
"Partei":
{
"type": "object",
"properties":
{
"Name":
{
"type": "string"
},
"Hauptsitz":
{
"type": "string"
},
"Gründungsdatum":
{
"type": "date"
},
"Gründungsort":
{
"type": "string"
}
}
},
"Amt":
{
"type": "string"
}
}
}
</syntaxhighlight>
Das obige JSON Schema kann verwendet werden, um die Gültigkeit des folgenden Datenblocks zu testen:
<syntaxhighlight lang="json">
{
"Vorname": "Ronald",
"Nachname": "Reagan",
"Geburtsdatum": "1911-02-06",
"Nationalität": "US-amerikanisch",
"Partei":
{
"Name": "Republican Party",
"Hauptsitz": "Washington, D.C.",
"Gründungsdatum": "1854-03-20",
"Gründungsort": "Ripon"
},
"Amt": "US-Präsident"
}
</syntaxhighlight>

== Vergleich mit XML ==
Sowohl JSON als auch [[Extensible Markup Language|XML]] beschreiben die Struktur eines Datensatzes. Der Datensatz kann weitere Datensätze enthalten, dadurch sind beliebig tief verschachtelte Strukturen möglich.

In XML sind die einzelnen Knoten der Datenstruktur benannt, während die Knoten in JSON unbenannt sind.

In XML können einfache Zeichenketten sowohl als Attribut eines Elements als auch als eigenständiges Element beschrieben sein, in JSON gibt es diese Unterscheidung nicht. Diese in den meisten Fällen irrelevante Flexibilität führt dazu, dass sich die Struktur von XML-Dokumenten häufig unnötigerweise unterscheidet.

Sowohl für JSON als auch für XML gibt es Beschreibungssprachen, um weiter einzugrenzen, wie „gültige“ Dokumente aussehen, im Gegensatz zu „wohlgeformten“ Dokumenten.

Die Syntax von JSON ist sehr viel einfacher gestaltet und erscheint daher oft lesbarer und insbesondere leichter schreibbar. In der Regel produziert JSON auch geringeren [[Overhead (EDV)|Overhead]] im Vergleich zu XML.

Sowohl JSON als auch XML<ref>{{Internetquelle |url=https://file-types.com/docs/json |titel=JSON Documentation |werk=file-types.com |datum=2020-01-18 |sprache=en |abruf=2021-10-10}}</ref> müssen von einem speziellen Parser eingelesen werden. Traditionell ist jedes wohlgeformte JSON-Dokument ein gültiger JavaScript-Ausdruck, das sorglose Interpretieren von JSON-Dokumenten mit <code>eval()</code> stellt jedoch potentiell eine [[Sicherheitslücke]] dar und kann beispielsweise [[Cross-Site-Scripting]] (XSS) ermöglichen.<ref>{{Internetquelle |autor=Amakiri Welekwe |url=https://www.comparitech.com/net-admin/json-injection-guide/ |titel=What is a JSON Injection and How to Prevent it? |werk=comparitech.com |datum=2022-03-09 |sprache=en |abruf=2023-12-16}}</ref>

Sowohl JSON als auch XML sind nicht gut zum Repräsentieren von [[Binärdatei|Binärdaten]] geeignet, da beide Datenformate als Grundelement zeichenbasiert sind und nicht bytebasiert.

Zum Vergleich das oben genannte Beispiel in einer XML-Form:

<syntaxhighlight lang="xml">
<Kreditkarte Herausgeber="Xema" Nummer="1234-5678-9012-3456" Deckung="2e+6" Waehrung="EURO">
<Inhaber Name="Mustermann" Vorname="Max" Teilnahme_am_Bonusprogramm="true" Alter="42" Partner="null">
<Hobbys>
<Hobby>Reiten</Hobby>
<Hobby>Golfen</Hobby>
<Hobby>Lesen</Hobby>
</Hobbys>
<Kinder />
</Inhaber>
</Kreditkarte>
</syntaxhighlight>

Nach Entfernung der optionalen Leerzeichen ist das JSON-Objekt 226 Byte, das XML-Objekt 279 Byte groß – ein Zuwachs um 23 %.<br />Oftmals können Attribute auch als Kindknoten formuliert werden, das Beispiel könnte dann wie folgt aussehen:

<syntaxhighlight lang="xml">
<Kreditkarte>
<Herausgeber>Xema</Herausgeber>
<Nummer>1234-5678-9012-3456</Nummer>
<Deckung>2e+6</Deckung>
<Waehrung>EURO</Waehrung>
<Inhaber>
<Name>Mustermann</Name>
<Vorname>Max</Vorname>
<Teilnahme_am_Bonusprogramm>true</Teilnahme_am_Bonusprogramm>
<Hobbys>
<Hobby>Reiten</Hobby>
<Hobby>Golfen</Hobby>
<Hobby>Lesen</Hobby>
</Hobbys>
<Alter>42</Alter>
<Kinder />
<Partner>null</Partner>
</Inhaber>
</Kreditkarte>
</syntaxhighlight>
Dieses Objekt wäre mit Entfernung der Leerzeichen 361 Byte groß – ein Zuwachs um 60 % zum JSON-Objekt. 

== {{Anker|JSONP}} JSONP (JSON mit Padding) ==
Bei JSONP (JSON mit Padding) werden die JSON-Daten über ein <code><script></code>-Element eingebunden und inklusive eines Funktionsaufrufs ausgegeben. Dies ermöglicht die [[Datenübertragung|Übertragung]] von JSON-Daten über [[Domain (Internet)|Domaingrenzen]], ist jedoch mit Sicherheitsrisiken behaftet.

JSONP wurde 2005 von Bob Ippolito vorgestellt<ref>{{Internetquelle |url=https://bob.ippoli.to/javascript/mochikit/ajax/archives/2005/12/05/remote-json-jsonp |titel=Remote JSON – JSONP |werk=Bob.pythonmac.org |datum=2005-12-05 |sprache=en |abruf=2011-01-23 |kommentar=from __future__ import *}}</ref> und wird jetzt von vielen Web-2.0-Anwendungen wie [[Dojo Toolkit]], [[jQuery]],<ref>{{Internetquelle |url=https://api.jquery.com/jQuery.getJSON/ |titel=jQuery API |werk=api.jquery.com |sprache=en |abruf=2011-01-23}}</ref> [[Google Web Toolkit]] Applications<ref>{{Internetquelle |url=http://www.gwtapps.com/?p=42 |titel=GWT Tutorial: How to Read Web Services Client-Side with JSONP |werk=Google Web Toolkit Applications |datum=2008-02-06 |sprache=en |offline=1 |archiv-url=https://web.archive.org/web/20080213044253/http://www.gwtapps.com/?p=42 |archiv-datum=2008-02-13 |abruf=2011-01-23}}</ref> und Web Services unterstützt. Für dieses Protokoll wurden Erweiterungen vorgeschlagen, die zusätzliche Eingabeparameter ermöglichen, wie z. B. JSONPP.<ref>{{Internetquelle |autor=Jonas Almeida |url=https://sites.google.com/a/s3db.org/s3db/documentation/mis/json-jsonp-jsonpp |titel=JSON, JSONP, JSONPP? |hrsg=S3DB |datum=2008-06-11 |sprache=en |archiv-url=https://web.archive.org/web/20100524144722/https://sites.google.com/a/s3db.org/s3db/documentation/mis/json-jsonp-jsonpp |archiv-datum=2010-05-24 |abruf=2011-01-23}}</ref>

=== Funktionsweise ===

Üblicherweise erfolgen [[Ajax (Programmierung)|Ajax]]-Datenabfragen an [[Server]] über das [[XMLHttpRequest]]-Objekt eines [[Webbrowser]]s. Aufgrund der [[Same-Origin-Policy]] funktioniert das nicht, wenn die in einem Webbrowser angezeigte [[Webseite]] über dieses Objekt auf einen Server zuzugreifen versucht, der in einer anderen Domain als die angezeigte Webseite liegt. Das Problem kann durch JSONP umgangen werden. Im <code>src</code>-Attribut eines [[HTML#HTML-Kopf|<code><script></code>-Elements]] ist es möglich, beliebige URLs anzugeben. Für dieses Attribut greift die Same-Origin-Policy nicht. Es ist also möglich, eine URL in einer anderen Domain anzugeben, die beispielsweise JSON-Daten zurückgibt. Dieses Script hätte aber keinen Effekt.

Um die JSON-Daten auf dem [[Client]] verarbeiten zu können, verpackt der Server diese als Parameter in eine [[JavaScript#Funktionen|JavaScript-Funktion]], die im Webbrowser bereits definiert ist. Der Name dieser Funktion wird dem Server üblicherweise im [[Query-String]] der URL mitgeteilt, wobei das genaue Format oder der Name des Parameters nicht genormt ist.

Beispiel:

Im HTML-Code einer Webseite werden die JSONP-Daten wie folgt eingebunden:

<syntaxhighlight lang="html">
<script type="text/javascript"
src="https://example.com/getjson?jsonp=exampleCallback">
</script>
</syntaxhighlight>

Der Server erzeugt daraufhin einen JavaScript-Codeschnipsel, in dem die eigentlichen Daten an die genannte Funktion übergeben werden:

<pre>
exampleCallback( {"name":"Jane Doe", "value":4711} );
</pre>

Der Browser führt diesen Funktionsaufruf daraufhin aus, als ob er direkt in der HTML-Seite niedergeschrieben worden wäre, und kann so die JSON-Daten aus dem Aufruf verarbeiten.

Üblicherweise ist für jeden JSONP-Aufruf ein eigenes [[HTML#HTML-Kopf|<code><script></code>-Element]] erforderlich.

=== Sicherheitsrisiken ===
<code><script></code>-Elemente ermöglichen es einem Server, ''beliebige'' Inhalte (nicht nur JSON-Objekte) an den Webbrowser zu übermitteln. Dies kann dazu führen, dass ein bösartiger Web-Service über die zurückgesendeten Daten private Informationen im Webbrowser ausspäht oder in seinem Sinne verändert ([[Cross-Site-Scripting]]).

Da das <code><script></code>-Element die [[Same-Origin-Policy]] nicht beachtet, kann eine bösartige Webseite JSONP-Daten anfordern und auswerten, die nicht für sie bestimmt sind ([[Cross-Site-Request-Forgery]]).<ref>{{Internetquelle |autor=Jeremiah Grossman |url=https://blog.jeremiahgrossman.com/2006/01/advanced-web-attack-techniques-using.html |titel=Advanced Web Attack Techniques using GMail |werk=blog.jeremiahgrossman.com |datum=2006-01-27 |sprache=en |abruf=2011-01-23}}</ref> Das Problem tritt dann auf, wenn sensible Daten vor Dritten geschützt werden sollen.

=== Alternative ===
Mit [[Cross-Origin Resource Sharing]] (CORS) existiert ein vergleichbares Verfahren, das den Zugriff über Domaingrenzen hinweg ermöglicht, ohne jedoch der abgefragten Ressource die Möglichkeit einzuräumen, beliebigen JavaScript-Code auszuführen. Beide Verfahren erfordern die Unterstützung durch die entsprechende Ressource, wobei CORS einfacher zu implementieren ist. Gleichzeitig erlaubt CORS eine einfache Einschränkung seitens der Ressource, von welchen Datenquellen (englisch „origins“, das sind URLs, Domänen o. ä.) sie genutzt werden kann.

CORS ist gegenüber JSONP meist zu bevorzugen, da CORS insgesamt einfacher und sicherer ist.

== Verwandte Techniken ==

=== JSON-basierte Formate ===

* [[GeoJSON]] dient zur Annotation von [[Geodaten]].
* [[JSON-LD]] dient zur Einbettung von [[Resource Description Framework|RDF]]-Daten.
* [[JSON-RPC]] dient zum Aufruf von Methoden in entfernten Computersystemen.
* [[JSON Feed]] dient zur Beschreibung von Web-Feeds.
* Die [[Hypertext Application Language]]<ref>{{Internetquelle |autor=Mike Kelly |url=https://tools.ietf.org/html/draft-kelly-json-hal-08 |titel=JSON Hypertext Application Language |hrsg=[[Internet Engineering Task Force|IETF]] Network Working Group |datum=2016-10-12 |sprache=en |abruf=2016-12-07}}</ref> (HAL) dient zur Implementierung von [[HATEOAS]] in auf JSON basierten [[Representational State Transfer|REST-Schnittstellen]].
* JSON Hyper-Schema<ref>{{Internetquelle |autor=Austin Wright, Geraint Luff |url=https://json-schema.org/latest/json-schema-hypermedia.html |titel=JSON Hyper-Schema: A Vocabulary for Hypermedia Annotation of JSON |hrsg=[[Internet Engineering Task Force|IETF]] |datum=2016-08-13 |sprache=en |abruf=2016-12-07 |archiv-datum=2016-12-07 |archiv-url=https://web.archive.org/web/20161207131655/http://json-schema.org/latest/json-schema-hypermedia.html |offline=ja |archiv-bot=2025-03-21 02:24:51 InternetArchiveBot }}</ref> dient zur Annotation von Datentypen in JSON.
* GBSON<ref>{{Internetquelle |url=https://chlorobox.mpimp-golm.mpg.de/GBSON-Documentation.html |titel=GBSON |titelerg=A new annotation file format based on JSON |sprache=en |abruf=2021-11-12}}</ref> dient zur Annotation von Nucleinsäuresequenzen ([[Desoxyribonukleinsäure|DNA]] und [[Ribonukleinsäure|RNA]]).

=== Alternative Formate ===

* [[YAML]], [[CSON]]<ref>{{Internetquelle |url=https://github.com/bevry/cson/blob/master/README.md |titel=CSON |werk=github.com |sprache=en |abruf=2023-12-16}}</ref> (''CoffeeScript-Object-Notation''), [[HOCON]]<ref>{{Internetquelle |url=https://github.com/lightbend/config/blob/main/HOCON.md |titel=HOCON |werk=github.com |sprache=en |abruf=2023-12-16}}</ref> (''Human-Optimized Config Object Notation''), [[JSON5]]<ref>{{Internetquelle |url=https://json5.org/ |titel=JSON5 – JSON for Humans |werk=json5.org |sprache=en |abruf=2023-12-16}}</ref> und [[Hjson]]<ref>{{Internetquelle |url=https://hjson.github.io/ |titel=Hjson, a user interface for JSON |werk=hjson.github.io |sprache=en |abruf=2023-12-16}}</ref> sind Datenserialisierungsformate, deren Syntax eine Obermenge von JSON ist. Sie erweitern JSON u. a. um Kommentare und erlauben eine für Menschen einfacher lesbare Syntax. Beispielsweise sind Anführungszeichen für Schlüssel und Zeichenketten, Kommas am Zeilenende und geschweifte Klammern teilweise optional.
* [[Jsonnet]],<ref>{{Internetquelle |url=https://jsonnet.org/ |titel=Jsonnet |werk=jsonnet.org |sprache=en |abruf=2023-12-16}}</ref> [[Dhall]]<ref>{{Internetquelle |url=https://dhall-lang.org/ |titel=The Dhall configuration language |werk=dhall-lang.org |sprache=en |abruf=2023-12-16}}</ref> und CUE<ref>{{Internetquelle |url=https://cuelang.org/ |titel=CUE: Configure Unify Execute |werk=cuelang.org |sprache=en |abruf=2023-12-16}}</ref> sind ebenfalls Obermengen von JSON und bieten Funktionen wie z. B. Validierung.
* [[JSON streaming]] mit den drei Varianten ''Line-delimited JSON'' (LDJSON), ''Newline-delimited JSON'' (NDJSON) und ''JSON lines'' (JSONL).
* [[Initialisierungsdatei|INI]], [[YAML]] und [[TOML]] sind Formate, die speziell für [[Konfigurationsdatei]]en entworfen wurden.

=== Binäre Formate ===

Binäre JSON-Varianten gibt es mit BSON (Binary JSON),<ref>{{Internetquelle |url=https://bsonspec.org/ |titel=BSON (Binary JSON) Serialization |werk=bsonspec.org |sprache=en |abruf=2023-12-16}}</ref> verwendet u. a. von [[MongoDB]], und mit JSONB, verwendet von [[PostgreSQL]].<ref>{{Internetquelle |url=https://www.postgresql.org/docs/12/datatype-json.html |titel=PostgreSQL 12 Documentation, 8.14. JSON Types |werk=postgresql.org |sprache=en |abruf=2023-12-16}}</ref> Einen ähnlichen Ansatz verfolgen Googles [[Protocol Buffers]] (protobuf), denen im Unterschied zu JSON bzw. BSON ein Schema zugrunde liegt.<ref>{{Internetquelle |url=https://protobuf.dev/ |titel=Protocol Buffers |werk=protobuf.dev |sprache=en |abruf=2023-12-16}}</ref><ref>{{Internetquelle |url=https://github.com/protocolbuffers/protobuf/blob/main/README.md |titel=Protocol Buffers – Google’s data interchange format |werk=github.com |sprache=en |abruf=2023-12-16}}</ref> Ebenfalls an JSON orientiert ist das schemalose und auf platzsparende Serialisierung und Prozessierungsgeschwindigkeit hin optimierte [[Concise Binary Object Representation|CBOR]].<ref>{{Internetquelle |url=https://cbor.io/ |titel=CBOR – Concise Binary Object Representation {{!}} Overview |werk=cbor.io |sprache=en |abruf=2019-02-16}}</ref>

=== Vorgänger-Formate ===

Vor der Verbreitung von JSON war [[Extensible Markup Language|XML]] das bekannteste Datenserialisierungsformat.

[[NeXTstep]] verwendete bereits einige Jahre früher, spätestens seit 1994, eine ähnliche Technik, um einfache Objektbäume zu laden oder zu speichern. Sie heißen dort [[Property List]]s und sind bis heute in [[macOS]] in Verwendung. Diese erlauben ebenfalls die Speicherung von Werten der Typen ''Array'', ''Dictionary'', boolescher Wert, Binärdaten, Datum, Zahl und Zeichenketten.<ref>{{Internetquelle |url=https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/PropertyLists/Introduction/Introduction.html |titel=Introduction to Property Lists |werk=developer.apple.com |sprache=en |abruf=2011-11-06}}</ref><ref>{{Internetquelle |url=https://www.nextcomputers.org/NeXTfiles/Docs/NeXTStep/3.3/nd/Foundation/Classes/NSStringClassCluster.htmld/index.html |titel=NSString Class Cluster – propertyList Methode |werk=NeXTStep 3.3 Developer Documentation Manuals |hrsg=nextcomputers.org |datum=2000-06-30 |sprache=en |abruf=2022-07-20}}</ref>

Die [[Tcl|Tool Command Language]] kennt ''Dictionaries'' (dict), die ebenfalls beliebig geschachtelte, benannte Strukturen enthalten können. Diese sind gleichfalls strukturierte Zeichenketten. Der Zusatzaufwand (englisch „overhead“) ist gegenüber JSON deutlich vermindert, weil keine Doppelpunkte oder Anführungsstriche benötigt werden. Eine klare Trennung zwischen Objektstrukturen (Eigenschaft/Wert) und Tabellen („arrays“, hier als Listen bezeichnet) gibt es allerdings nicht. Daher ist eine Überführung von JSON-Daten in ein ''dict'' immer eindeutig und leicht möglich, umgekehrt jedoch nicht.

== Weblinks ==
{{Commonscat|JavaScript Object Notation|audio=1|video=1}}
* [https://json.org/json-de.html json.org/json-de.html] – deutsche Einführung auf der offiziellen JSON-Seite (weitere Sprachen verfügbar)
* [https://www.developer.com/lang/jscript/article.php/3596836 Speeding Up AJAX with JSON] Einführung in JSON, bei der die Unterschiede zu XML herausgearbeitet werden (englisch)
* [https://seriot.ch/parsing_json.php Parsing JSON is a Minefield] – Übersicht der verschiedenen Standards und Implementierungen (englisch)
* [https://codifyformatter.org/jsonviewer Online JSON Viewer] for Formatting, Validating, and Sharing JSON Data
* [https://codebeautify.org/jsonviewer JSON Viewer] Online-Plattform zum Formatieren, Validieren und Austausch von JSON-Daten (englisch)
* [http://jsonp.eu/ jsonp.eu] – Erklärungen und Programmierbeispiele zu ''JSON with Padding'' (JSONP)
* [https://jsonparser.ai/json-fixer JSON-zu-Fixierungstool] Erkennt automatisch die Probleme im JSON-Code und behebt sie.
* [https://onlinejsonformatter.com/json-viewer JSON Viewer Online] Plattformen sind für das Debuggen und Optimieren von JSON-Code in Echtzeitprojekten unerlässlich.

== Einzelnachweise ==
<references responsive>
<ref name="RFC7159">
{{RFC-Internet |Autor=Tim Bray |RFC=7159 |Titel=The JavaScript Object Notation (JSON) Data Interchange Format |Datum=2014-03}}
</ref>
<ref name="RFC8259">
{{RFC-Internet |RFC=8259 |Titel=The JavaScript Object Notation (JSON) Data Interchange Format |Datum=2017 |Autor=Douglas Crockford}}
</ref>
<ref name="ECMA-404">
[https://www.ecma-international.org/publications-and-standards/standards/ecma-404 ECMA-404]
</ref>
</references>

{{Normdaten|TYP=s|GND=1105592812|LCCN=sh2014000515}}

[[Kategorie:Web-Entwicklung|JSON]]
[[Kategorie:Datenserialisierungformat|JSON]]
[[Kategorie:Beschreibungssprache|JSON]]
[[Kategorie:JSON| ]]

JSON - Versionsgeschichte

imported>Faisalhussain2008: Erkennt automatisch die Probleme im JSON-Code und behebt sie.