Was ist der Unterschied zwischen JSON und Objektliteral Notation?

https://stackoverflow.com/questions/2904131

04-10-2019
|

Frage

Kann jemand mir sagen, was der Hauptunterschied zwischen einem JavaScript-Objekt definiert, indem Sie Objektliteral Notation und JSON-Objekt

Nach einem JavaScript-Buch sagt, dass es das ist eine Aufgabe, die durch Verwendung von Object Notation :

var anObject = {
    property1 : true,
    showMessage : function (msg) { alert(msg) }
};

Warum ist es nicht ein JSON-Objekt in diesem Fall? Nur weil es durch die Verwendung Anführungszeichen nicht definiert ist?

Lösung

Hier kann zunächst klären, was JSON tatsächlich ist. JSON ist ein Text , sprach indepedent Datenaustauschformat, ähnlich wie XML, CSV oder YAML.

Die Daten können auf vielfältige Weise gespeichert werden, aber wenn es in einer Textdatei gespeichert werden soll und von einem Computer lesbar sein, braucht es eine gewisse Struktur zu folgen. JSON ist eine der vielen Formaten, die eine solche Struktur definieren.

Eine solche Formate typischerweise sprachunabhängig sind, dh sie können von Java, Python, JavaScript, PHP verarbeitet werden, können Sie es nennen.

Im Gegensatz dazu JavaScript ist eine Programmiersprache. Natürlich JavaScript bietet auch eine Möglichkeit, Daten zu definieren / beschreiben, aber die Syntax ist sehr spezifisch für JavaScript.

Als Gegenbeispiel hat Python das Konzept von Tupeln , deren Syntax ist (x, y). JavaScript muss nicht so etwas.

Lets Blick auf die syntaktischen Unterschiede zwischen JSON und JavaScript Objektliterale.

JSON hat folgende syntaktische Einschränkungen:

Objekt Tasten muss Strings (das heißt eine Zeichenfolge in doppelten Anführungszeichen " eingeschlossen).
Die Werte können entweder:
- eine Zeichenfolge
- eine Zahl
- ein (JSON) Objekt
- ein Array
- true
- false
- null
Doppelte Schlüssel ({"foo":"bar","foo":"baz"}) produzieren nicht definiert, implementierungsspezifische Ergebnisse; die JSON-Spezifikation speziell definiert nicht, ihre Semantik

In JavaScript Objektliterale hat

Stringliterale, Zahlenliterale oder Identifikator Namen als Schlüssel (da ES6, Schlüssel kann nun auch berechnet werden, welche noch eine andere stellt Syntax).
Die Werte können jede gültige JavaScript-Ausdruck, einschließlich Funktionsdefinitionen und undefined.
Doppelte Schlüssel erzeugen definiert, angegeben Ergebnisse (in losem Modus, letztere Definition ersetzt die frühere, im strikten Modus, es ist ein Fehler).

Das Wissen, dass seine gerade Blick auf den Syntax , Ihr Beispiel ist nicht JSON aus zwei Gründen:

Ihre Schlüssel nicht Strings (Literale). Sie sind Bezeichnernamen .
Sie können keine Funktion als Wert zu einem „JSON-Objekt“ zuweisen (weil JSON keine Syntax für Funktionen definieren).

Aber am wichtigsten ist, meine Erklärung zu wiederholen, von Anfang an: Sie sind in einem JavaScript-Kontext. Sie definieren ein Objekt JavaScript. Wenn überhaupt, kann ein „JSON-Objekt“ nur in einem String enthalten sein:

 var obj = {foo: 42}; // creates a JavaScript object (this is *not* JSON)
 var json = '{"foo": 452}'; // creates a string containing JSON

Das heißt, wenn Sie JavaScript-Quellcode schreiben, und es nicht mit einem string , du bist nicht mit JSON tun. Vielleicht erhalten Sie die Daten als JSON (zum Beispiel über Ajax oder aus einer Datei zu lesen), aber wenn Sie oder eine Bibliothek Sie verwenden es analysiert hat, ist es nicht JSON mehr.

Nur weil Objektliterale und JSON-Look ähnlich , es bedeutet nicht, dass man sie untereinander austauschbar benennen Siehe auch gibt es so etwas wie ein "JSON-Objekt" .

Andere Tipps

JSON hat eine viel begrenzte Syntax einschließlich:

Schlüsselwerte müssen in Anführungszeichen gesetzt werden
Strings müssen mit " zitiert werden und nicht '
Sie haben eine begrenzte Anzahl von Werten (z keine Funktionen erlaubt)

Es ist wirklich nicht so etwas wie ein „JSON-Objekt“.

Die JSON spec ist eine Syntax für Daten als eine Zeichenkette kodiert. Was für Leute nennen ein „JSON-Objekt“ (in Javascript) ist wirklich nur ein gewöhnliches Javascript-Objekt, das (wahrscheinlich) gewesen von einem gültig JSON-String de-serialisiert hat, und kann als ein gültigen JSON-String leicht wieder serialisiert wird. Dies bedeutet im Allgemeinen, dass es nur die Daten (und nicht die Funktionen) enthält. Es bedeutet auch, dass es keine Termine gibt, weil JSON kein Datum Typ haben (wahrscheinlich die schmerzhafteste Sache über JSON;)

Darüber hinaus (Neben rant ...), wenn die Menschen über ein „JSON-Objekt“ zu sprechen, sie fast immer bedeuten, Daten, die die „kraus Klammern“ auf der obersten Ebene hat. Dies entspricht gut zu einem JavaScript-Objekt. Allerdings erfordert die JSON-Spezifikation nicht, dass es ein einziges sein „kraus Zahnspange“ Objekt auf der obersten Ebene eines JSON-String. Es ist vollkommen gültig JSON eine Liste auf der obersten Ebene zu haben, oder auch nur einen einzigen Wert zu haben. Also, während jeder „JSON-Objekt“ entspricht gültig JSON, nicht alle gültigen JSON-Strings entsprechen dem, was wir einen „JSON-Objekt“ nennen würde! (Da die Zeichenfolge eine Liste oder einen atomaren Wert darstellen könnte)

JSON in JavaScript ,

JSON ist ein Subset des Objekts wörtliche Notation von JavaScript.

Mit anderen Worten, gültig JSON gilt auch JavaScript Objektliteral Schreibweise aber nicht unbedingt umgekehrt.

Neben dem Lesen der Dokumentation , wie @Filix König vorgeschlagen, schlage ich vor, auch um mit der Wiedergabe < a href = "http://www.jsonlint.com/" rel = "noreferrer"> JSONLint Online-JSON-Validator . So habe ich gelernt, dass die Schlüssel von JSON-Objekte müssen Strings sein.

?? JSON : The Fat-Free Alternative zu XML

JSON wurde von Menschen weithin angenommen haben festgestellt, dass es es machte viel einfacher, verteilte Anwendungen und Dienstleistungen zu produzieren. Der offizielle Internet-Medientyp für JSON ist application/json RFC 4627 . JSON-Dateinamen verwenden, um die Erweiterung .json.

? JavaScript Object Notation ( JSON ) ist ein leichter, textbasierte, sprachunabhängigen Datenaustausch Format. JSON hat zum Austausch von Daten zwischen Anwendungen in jeder beliebigen Programmiersprache geschrieben verwendet.

Die JSON Objekt ein einzelnes Objekt, das zwei Funktionen enthält, parsen und stringify, die zu parsen und Konstrukts JSON Texte verwendet werden.

JSON.stringify erzeugt einen String, dass entspricht den folgenden JSON Grammatik.

JSON.parse akzeptiert eine Zeichenfolge, die entspricht der JSON Grammatik.

Die parseJSON Methode wird in der Fourth Edition of ECMAScript aufgenommen werden . In der Zwischenzeit ist eine JavaScript-Implementierung bei json.org zur Verfügung.

var objLiteral = {foo: 42}; // JavaScript Object
console.log('Object Literal : ', objLiteral ); // Object {foo: 42}foo: 42__proto__: Object

// This is a JSON String, like what you'd get back from an AJAX request.
var jsonString = '{"foo": 452}';
console.log('JOSN String : ', jsonString ); // {"foo": 452}

// This is how you deserialize that JSON String into an Object.
var serverResposnceObject = JSON.parse( jsonString );
console.log('Converting Ajax response to JavaScript Object : ', serverResposnceObject); // Object {foo: 42}foo: 42 __proto__: Object

// And this is how you serialize an Object into a JSON String.
var serverRequestJSON = JSON.stringify( objLiteral );
console.log('Reqesting server with JSON Data : ', serverRequestJSON); // '{"foo": 452}'

JSON ist Teilmenge von JavaScript. Javascript aus dem ECMAScript Programming Language-Standard abgeleitet wurde.

? ECMAScript

hat ECMAScript sich zu einem der weltweit am weitesten verbreitete Allzweck-Programmiersprachen zu sein. Es ist am besten als die in Web-Browsern eingebettete Sprache bekannt, aber auch für Server und Embedded-Anwendungen weit verbreitet angenommen worden. ECMAScript basiert auf mehreren Ursprungstechnologien, die bekanntesten sind JavaScript (Netscape Kommunikation)) und JScript (Microsoft Corporation).) . Obwohl vor 1994, ECMA wurde als "European Computer Manufacturers Association" bekannt, nach 1994, als die Organisation wurde global, die "Marke" "Ecma" wurde aus historischen Gründen gehalten.

ECMAScript ist die Sprache, während JavaScript, JScript und sogar Actionscript aufgerufen werden "Dialects" .

Dialects wurden aus derselben Sprache abgeleitet. Sie sind recht ähnlich zueinander, wie sie aus der gleichen Sprache abgeleitet haben, aber sie haben erfahren haben einige Änderungen. Ein Dialekt ist eine Variation in der Sprache selbst. Es ist aus einer einzigen Sprache abgeleitet.

SQL Sprache -. Hibernate MySQL Dialect, Oracle Dialect, .., die einige Änderungen oder zusätzliche Funktionen haben

Informationen über den Browser und Computer des Benutzers.

navigator.appName // "Netscape"

ECMAScript ist die Skriptsprache, die die Grundlage von JavaScript bildet. JavaScript language resources .

ECMA-262 Links
Initial Edition, June 1997 PDF.
2nd Edition, August 1998 PDF.
3rd Edition, December 1999 PDF.
5th Edition, December 2009 PDF.
5.1 Edition, June 2011 HTML.
6th Edition, June 2015 HTML.
7ᵗʰ Edition, June 2016 HTML.
8th edition, June 2017 HTML.
9th Edition, 2018 HTML.

Hinweis « 4. Auflage von ECMAScript nicht veröffentlicht, wie die Arbeit war unvollständig .

JSON definiert einen kleinen Satz von Formatierungsregeln für die portable Darstellung von strukturierten Daten.

? Schlüsselwerte angegeben werden müssen, werden nur Strings für Schlüssel erlaubt. Bei Verwendung als String wird es in String konvertieren. Aber nicht empfohlen andere Tasten als String zu bedienen ist. Hier finden Sie ein Beispiel, wie diese - { 'key':'val' } über RFC 4627 - jsonformatter

var storage = {
  0 : null,
  1 : "Hello"
};
console.log( storage[1] ); // Hello
console.log( JSON.stringify( storage ) ); // {"0":null,"1":"Hello","2":"world!"}

var objLiteral = {'key1':'val1'};
    var arr = [10, 20], arr2 = [ 'Yash', 'Sam' ];
    var obj = { k: 'v' }, obj2 = { k2: 'v2' };
    var fun = function keyFun() {} ;

objLiteral[ arr ] = 'ArrayVal';     objLiteral[ arr2 ] = 'OverridenArrayVal';
objLiteral[ obj ] = 'ObjectVal';    objLiteral[ obj2 ] = 'OverridenObjectVal';
objLiteral[ fun ] = 'FunctionVal';

console.log( objLiteral );
// Object {key1: "val1", 10,20: "ArrayVal", Yash,Sam: "OverridenArrayVal", [object Object]: "OverridenObjectVal", function keyFun() {}: "FunctionVal"}
console.log( JSON.stringify( objLiteral ) );
// {"key1":"val1","10,20":"ArrayVal","Yash,Sam":"OverridenArrayVal","[object Object]":"OverridenObjectVal","function keyFun() {}":"FunctionVal"}
console.log( JSON.parse( JSON.stringify( objLiteral ) ) );
// Object {key1: "val1", 10,20: "ArrayVal", Yash,Sam: "OverridenArrayVal", [object Object]: "OverridenObjectVal", function keyFun() {}: "FunctionVal"}

console.log('Accessing Array  Val : ', objLiteral[ [10,20] ] );
console.log('Accessing Object Val : ', objLiteral[ '[object Object]' ] );
console.log('Accessing Function Val : ', objLiteral[ 'function keyFun() {}' ] );

? JSON Strings müssen mit "und nicht‘ angegeben werden. Ein String ist sehr ähnlich wie ein C oder Java-String. Strings sollte in doppelten Anführungszeichen eingewickelt werden.
- Literale festen Werte sind, nicht Variablen, dass Sie buchstäblich in Ihrem Skript zur Verfügung stellen.
- Ein String ist eine Folge von null oder mehr Zeichen in Anführungszeichen mit umgekehrter Schrägstrich Hemmung gewickelt, die gleichen Schreibweise in den meisten Programmiersprachen verwendet.
  - ?? -. Sonderzeichen in String erlaubt sind aber nicht beschränkt auf die Verwendung empfohlen
  - \“- Sonderzeichen können entkommen, aber nicht zu entkommen empfohlen ( ') einfache Anführungszeichen.. In Strict-Modus wird es werfen und Fehler - SyntaxError: Unexpected token ' in JSON
Überprüfen Sie mit diesem Code { "Hai\" \n Team 🔫":5, "Bye \'": 7 } über Online-JSON Edtions. Modes notStrict , Strinct .
```
var jsonString = "{'foo': 452}"; // {'foo': 452}
var jsonStr = '{"foo": 452}'; // {"foo": 452}

JSON.parse( jsonString ); // Unexpected token ' in JSON at position 1(…)
JSON.parse( jsonStr ); // Object {foo: 452}

objLiteral['key'] = 'val'; // Object {foo: 42, key: "val"}
objLiteral.key2 = 'val';

// objLiteral.key\n3 - SyntaxError: Invalid or unexpected token
objLiteral['key\n3'] = 'val'; // Object {"foo": "42", key: "val", key2: "val", "key↵3": "val"}

JSON.stringify( objLiteral ); // {"foo":"42","key":"val","key2":"val","key\n3":"val"}
```

Eigenschaftenaccessoren Zugang bieten um die Eigenschaften eines Objekts durch die Punktnotation oder die Klammer-Notation.

? Sie haben eine begrenzte Anzahl von Werten (z keine Funktionen erlaubt). Ein Wert kann eine Zeichenfolge in doppelten Anführungszeichen, Zahl, boolean, null, ein Objekt oder Array sein. Diese Strukturen können verschachtelt werden.

var objLiteral = {};
objLiteral.funKey = function sayHello() {
    console.log('Object Key with function as value - Its outcome message.');
};

objLiteral['Key'] = 'Val';

console.log('Object Literal Fun : ', objLiteral );
// Object Literal Fun :  Object {Key: "Val"}Key: "Val"funKey: sayHello()__proto__: Object
console.log( JSON.stringify( objLiteral ) ); // {"Key":"Val"}

? JavaScript ist die populärste Implementierung der ECMAScript-Standard. Die Kernfunktionen von Javascript auf dem ECMAScript-Standard basieren, aber Javascript hat auch andere zusätzliche Funktionen, die nicht in den ECMA-Spezifikationen / Standard sind. Jeder Browser hat ein JavaScript-Interpreter.

ist JavaScript eine dynamisch typisierte Sprache. Das heißt, Sie müssen nicht den Datentyp einer Variablen angeben, wenn Sie es deklarieren und Datentypen werden automatisch umgewandelt, wie es während der Skriptausführung benötigt.

Literals :

'37' - 7    // 30
'37' + 7    // "377"
+'37' + 7   // 44
+'37'       // 37
'37'        // "37"

parseInt('37');     // 37
parseInt('3.7');    // 3

parseFloat(3.7);    // 3.7

// An alternative method of retrieving a number from a string is with the + (unary plus) operator:
+'3.7'              // 3.7

Object literals RFC 7159

Eine Objektstruktur ist neuumgebenden null oder mehr Namen / Wert-Paare (oder Elemente) als ein Paar von geschweiften Klammern dargestellt. Ein Name ist ein String. Ein einzelner Doppelpunkt kommt nach jedem Namen, den Namen aus dem Wert trennt. Ein Komma trennt einen Wert aus einem folgenden Name. Die Namen innerhalb eines Objekts sollte eindeutig sein.

ECMAScript unterstützt Prototyp-basierte Vererbung. Jeder Konstruktor hat einen zugehörigen Prototyp, und jedes Objekt von diesem Konstruktor erstellt hat einen impliziten Verweis auf das Prototyp (das Objekt aufgerufen Prototyp) mit seinem Konstruktor verbunden. Darüber hinaus kann ein Prototyp einen nicht-null impliziten Hinweis auf den Prototyp hat, und so weiter; dies ist der Prototyp-Kette.

genannt

In einer klassenbasierten objektorientierten Sprache im allgemeinen Zustand von Fällen durchgeführt wird, werden Methoden von Klassen getragen und Vererbung ist nur von Struktur und Verhalten. In ECMAScript werden der Zustand und Methoden von Objekten getragen und Struktur, Verhalten und Zustand sind alle vererbt.

Ein Prototyp ist eine Aufgabe verwendet Struktur zu implementieren, Zustand und Verhalten Vererbung in ECMAScript. Wenn ein Konstruktor ein Objekt erstellt, verweist auf das Objekt implizit den dazugehörigen Prototyp Konstruktor für den Zweck Eigenschaft Verweise aufzulösen. Der zugehörige Konstruktor Prototyp kann durch das Programm Ausdruck constructor.prototype referenziert werden, und die Eigenschaften eines Objekts Prototyp hinzugefügt werden geteilt durch Vererbung von allen Objekten des Prototyps teilen.

Für diejenigen, die immer noch denken, dass RFC sind wichtiger als Blogs und Beurteilung aufgrund Missverständnisse, wollen wir versuchen, einige Punkte zu beantworten klären. Ich werde nicht all richtigen Unterschiede bereits in früheren Antworten erwähnt wiederholen, hier bin ich nur ein Mehrwert versuchen, einigen entscheidenden Teils einer Zusammenfassung rfc7159

Auszüge aus https://tools.ietf.org/html/rfc7159

JavaScript Object Notation (JSON) ist ein Textformat für die Serialisierung von strukturierten Daten. Es ist abgeleitet von dem Objekt Literale von JavaScript, wie in der ECMAScript Programming definiert Sprache Standard Third Edition [ECMA-262].
JSON können vier primitive Typen (Strings, Zahlen, Boolesche Werte darstellen, und null) und zwei strukturierte Typen ( Objekte und Arrays).
Ein Objekt ist eine ungeordnete Sammlung von null oder mehr Namen / Wert Paaren, wobei ein Name ein String ist, und ein Wert ist eine Zeichenfolge, Zahl, boolean, null, Objekt oder Array.
beginnen Objekt = ws% X7b ws; {Links geschweifte Klammer
End-Objekt = ws% X7D ws; } Geschweifte Klammer
A JSON Wert muss ein sein Objekt , Array, eine Zahl oder eine Zeichenfolge oder ein von die folgenden drei Literalnamen: false null true
An Objekt Struktur wird als ein Paar von geschweiften Klammern dargestellt
Die Namen innerhalb eines Objekt sollte eindeutig sein. Objekt = beginnt Objekt [Mitglied * (Wert-Separatorelement)] End-Objekt
Ein Objekt , deren Namen sind alle einzigartig ist interoperabel im Sinne dass alle Software-Implementierungen, die Objekt Empfang wird vereinbaren die Name-Wert-Zuordnungen. Wenn die Namen innerhalb eines Objekt sind nicht einzigartig, das Verhalten von Software, die eine solche Objekt empfängt, unberechenbar.

Beispiele (ab Seite 12 der RFC)

Dies ist ein JSON-Objekt:

      {
        "Image": {
            "Width":  800,
            "Height": 600,
            "Title":  "View from 15th Floor",
            "Thumbnail": {
                "Url":    "http://www.example.com/image/481989943",
                "Height": 125,
                "Width":  100
            },
            "Animated" : false,
            "IDs": [116, 943, 234, 38793]
          }
      }

Sein Bildelement ein Objekt , deren Thumbnail Mitglied ist ein Objekt und deren IDs Element ist eine Anordnung von Zahlen.

Es ist wirklich nicht so etwas wie ein „JSON-Objekt“.

Wirklich?

Soweit ich der größte Unterschied verstehen, ist die Flexibilität .

JSON ist eine Art Wrapper auf „JavaScript Object Notation“, die Kräfte Benutzer zur Definition der Objekte strengere Regeln zu gehorchen. Und es tut dies durch die mögliche Objektdeklaration Möglichkeiten von JavaScript Object Notation Funktion bereitgestellt begrenzen.

Als Ergebnis haben wir ein einfacheres und standardisierte Objekte, die Anzüge besser auf dem Datenaustausch zwischen den Plattformen.

Also im Grunde die newObject in meinem obigen Beispiel ist ein Objekt definiert, indem Sie JavaScript Objeect Notation; aber es ist nicht ein ‚gültig‘ JSON-Objekt, weil es den Regeln nicht folgen, dass JSON-Standards erfordern.

Dieser Link ist auch recht hilfreich: http://msdn.microsoft.com/en-us/library/bb299886. aspx

Zunächst sollten Sie wissen, was JSON ist:

Es ist sprachunabhängig Datenaustauschformat. Die Syntax von JSON wurde durch die JavaScript Object Notation Wörtliche inspiriert, aber es gibt Unterschiede zwischen ihnen.

Zum Beispiel in JSON alle Schlüssel müssen in Anführungszeichen gesetzt werden, während in Objektliterale dies nicht notwendig ist:

// JSON: { "Foo": "bar"}

// Objektliteral: var o = {foo: "bar"}; Die Zitate sind obligatorisch auf JSON, weil in JavaScript (. Genauer in ECMAScript 3rd Edition) wird die Nutzung der reservierten Worte als Eigenschaftsnamen nicht erlaubt, zum Beispiel:

var o = {if: "foo"}; // Syntax in ES3 Während einer Stringliteral als Eigenschaft Name (unter Angabe des Eigenschaftsnamen) verursacht keine Probleme:

var o = { "if": "foo"}; Also für „Kompatibilität“ (und leicht eval'ing vielleicht?) Die Anführungszeichen sind obligatorisch.

Die Datentypen in JSON werden auch auf die folgenden Werte beschränkt:

string Nummer Objekt Feld Eine wörtliche als: wahr falsch Null Die Grammatik von Strings ändert. Sie haben durch doppelte Anführungszeichen begrenzt werden, während in JavaScript, Sie austauschbar einfache oder doppelte Anführungszeichen verwenden können.

// Ungültige JSON: { "Foo": 'bar'} Die akzeptierte JSON Grammatik der Zahlen ändert sich auch in JavaScript Sie Hexadezimal-Literale verwenden können, zum Beispiel 0xFF, oder (die berüchtigten) Octal Literale z.B. 010. In JSON können Sie nur Dezimal Literale verwenden.

// Ungültige JSON: { "Foo": 0xFF}

Javascript Objektliteral vs JSON:

Objekt Literalsyntax ist eine sehr bequeme Art und Weise Javascript-Objekte zu erstellen
Die JSON Sprache, die für 'JavaScript Object Notation' steht, hat die Syntax von JavaScript-Objekt Literalsyntax abgeleitet. Es wird als Programmiersprache unabhängigen Textdatenübertragungsformat verwendet.

Beispiel:

JS Objekt Notation, in JS verwendet, um Objekte im Code zu erstellen bequem:

const JS_Object = {
  1: 2,  // the key here is the number 1, the value is the number 2
  a: 'b', // the key is the string a, the value is the string b
  func: function () { console.log('hi') }
  // the key is func, the value is the function
}

Beispiel von JSON:

{"widget": {
    "debug": "on",
    "window": {
        "title": "Sample Konfabulator Widget",
        "name": "main_window",
        "width": 500,
        "height": 500
    },
    "image": { 
        "src": "Images/Sun.png",
        "name": "sun1",
        "hOffset": 250,
        "vOffset": 250,
        "alignment": "center"
    },
    "text": {
        "data": "Click Here",
        "size": 36,
        "style": "bold",
        "name": "text1",
        "hOffset": 250,
        "vOffset": 100,
        "alignment": "center",
        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
    }
}}

Die Hauptunterschiede:

Alle Objektschlüssel in JSON müssen Strings sein. In Javascript Objektschlüssel können Strings oder Zahlen
Alle Strings in JSON muss in "Anführungszeichen" zitiert werden. Während in Javascript sowohl einzelne und doppelte Anführungszeichen sind erlaubt. Auch ohne Anführungszeichen in dem Objekt Javascript Notation der Objektschlüssel in Zeichenfolge implizit gegossen.
In JSON eine Funktion kann nicht als Wert eines Objekts definiert werden (da diese Javascript spezifisch ist). In Javascript ist dies völlig legal.

Javascript build in JSON Objekt:

JSON Objekte können leicht kehrt mit dem eingebauten in JSON Objekt, das Javascript bietet in seiner Laufzeit zu Javascript und umgerechnet werden. Zum Beispiel:

const Object = {
  property1: true,
  property2: false,
}; // creating object with JS object literal syntax

const JSON_object = JSON.stringify(Object);  // stringify JS object to a JSON string

console.log(JSON_object); // note that the (string) keys are in double quotes

const JS_object = JSON.parse(JSON_object);  // parse JSON string to JS object

console.log(JS_object.property1, JS_object.property2); 
// accessing keys of the newly created object

Dies ist ein überraschender Unterschied: Sie können nicht undefined in json verwenden und alle Objektfelder mit undefinierten Werten verschwinden nach JSON.stringify

let object =  { "a": undefined } ;

let badJSON= '{ "a": undefined }';


console.log('valid JS object :', object );
console.log('JSON from object:', JSON.stringify(object) );
console.log('invalid json    :', JSON.parse(badJSON) );

??????

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow