Kann mir jemand sagen , was der Hauptunterschied zwischen einem JavaScript - Objekt definiert durch die Verwendung Objektliteral Notation und Objekt JSON ?

Laut einem JavaScript-Buch heißt es, dass dies ein Objekt ist, das mithilfe der Objektnotation definiert wurde :

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

Warum ist es in diesem Fall kein JSON-Objekt? Nur weil es nicht durch Anführungszeichen definiert wird?

Lassen Sie uns zunächst klären, was JSON tatsächlich ist. JSON ist ein textuelles , sprachunabhängiges Datenaustauschformat, ähnlich wie XML, CSV oder YAML.

Daten können auf viele Arten gespeichert werden. Wenn sie jedoch in einer Textdatei gespeichert und von einem Computer lesbar sein sollen, müssen sie einer bestimmten Struktur folgen. JSON ist eines der vielen Formate, die eine solche Struktur definieren.

Solche Formate sind normalerweise sprachunabhängig, dh sie können von Java, Python, JavaScript, PHP verarbeitet werden.

Im Gegensatz dazu ist JavaScript eine Programmiersprache. Natürlich bietet JavaScript 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 lautet (x, y). JavaScript hat so etwas nicht.

Betrachten wir die syntaktischen Unterschiede zwischen JSON- und JavaScript-Objektliteralen.

JSON hat die folgenden syntaktischen Einschränkungen:

• Objektschlüssel müssen Strings (dh eine Zeichenfolge in Anführungszeichen ").
• Die Werte können entweder sein:
  • ein Faden
  • eine Zahl
  • ein (JSON) Objekt
  • eine Anordnung
  • true
  • false
  • null
• Doppelte Schlüssel ( {"foo":"bar","foo":"baz"}) führen zu undefinierten, implementierungsspezifischen Ergebnissen. Die JSON-Spezifikation definiert ihre Semantik nicht speziell

In JavaScript können Objektliterale haben

• String-Literale, Zahlenliterale oder Bezeichnernamen als Schlüssel (seit ES6 können jetzt auch Schlüssel berechnet werden, wodurch eine weitere Syntax eingeführt wird).
• Die Werte können beliebige gültige JavaScript-Ausdrücke sein, einschließlich Funktionsdefinitionen und undefined.
• Doppelte Schlüssel führen zu definierten, angegebenen Ergebnissen (im losen Modus ersetzt die letztere Definition die erstere; im strengen Modus ist dies ein Fehler).

Wenn Sie nur die Syntax betrachten , wissen Sie, dass Ihr Beispiel aus zwei Gründen nicht JSON ist:

1. Ihre Schlüssel sind keine Zeichenfolgen (Literale). Sie sind Bezeichnernamen .
2. Sie können einem "JSON-Objekt" keine Funktion als Wert zuweisen (da JSON keine Syntax für Funktionen definiert).

Vor allem aber, um meine Erklärung von Anfang an zu wiederholen: Sie befinden sich in einem JavaScript-Kontext. Sie definieren ein JavaScript-Objekt. Falls vorhanden, kann ein "JSON-Objekt" nur in einer Zeichenfolge 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 sich nicht mit einer Zeichenfolge befassen , haben Sie sich nicht mit JSON befasst. Möglicherweise haben Sie die Daten als JSON erhalten (z. B. über Ajax oder Lesen aus einer Datei), aber sobald Sie oder eine von Ihnen verwendete Bibliothek sie analysiert haben, ist sie nicht mehr JSON.

Nur weil Objektliterale und JSON ähnlich aussehen , bedeutet dies nicht, dass Sie sie austauschbar benennen können. Siehe auch Es gibt kein "JSON-Objekt" .

JSON hat eine viel eingeschränktere Syntax, einschließlich:

• Schlüsselwerte müssen in Anführungszeichen gesetzt werden
• Zeichenfolgen müssen mit "und nicht zitiert werden'
• Sie haben einen begrenzten Wertebereich (zB keine Funktionen erlaubt)

Es gibt wirklich kein "JSON-Objekt".

Die JSON-Spezifikation ist eine Syntax zum Codieren von Daten als Zeichenfolge. Was die Leute ein "JSON-Objekt" (in Javascript) nennen, ist eigentlich nur ein gewöhnliches Javascript-Objekt, das (wahrscheinlich) von einer gültigen JSON-Zeichenfolge de-serialisiert wurde und leicht als gültige JSON-Zeichenfolge neu serialisiert werden kann. Dies bedeutet im Allgemeinen, dass es nur Daten (und keine Funktionen) enthält. Dies bedeutet auch, dass es keine Daten gibt, da JSON keinen Datumstyp hat (wahrscheinlich das Schmerzlichste an JSON;)

Wenn Leute über ein "JSON-Objekt" sprechen, meinen sie fast immer Daten, die die "geschweiften Klammern" auf der obersten Ebene haben. Dies entspricht gut einem Javascript-Objekt. Die JSON-Spezifikation erfordert jedoch nicht, dass sich auf der obersten Ebene einer JSON-Zeichenfolge ein einzelnes Objekt mit geschweiften Klammern befindet. Es ist absolut gültig, dass JSON eine Liste auf der obersten Ebene oder sogar nur einen einzigen Wert hat. Während also jedes "JSON-Objekt" einem gültigen JSON entspricht, entsprechen nicht alle gültigen JSON-Zeichenfolgen dem, was wir als "JSON-Objekt" bezeichnen würden! (weil die Zeichenfolge eine Liste oder einen Atomwert darstellen könnte)

Nach JSON in JavaScript ,

JSON ist eine Teilmenge der Objektliteralnotation von JavaScript.

Mit anderen Worten, gültiger JSON ist auch eine gültige JavaScript-Objektliteralnotation, aber nicht unbedingt umgekehrt.

Zusätzlich zum Lesen der Dokumentation , wie von @Filix King vorgeschlagen, empfehle ich auch, mit dem JSONLint-Online-JSON-Validator herumzuspielen . So habe ich gelernt, dass die Schlüssel von JSON-Objekten Zeichenfolgen sein müssen.

🔫 JSON : Die fettfreie Alternative zu XML

JSON wurde von Menschen, die festgestellt haben, dass es die Erstellung verteilter Anwendungen und Dienste erheblich vereinfacht, weitgehend übernommen. Der offizielle Internet-Medientyp für JSON ist application/json RFC 4627. JSON-Dateinamen verwenden die Erweiterung .json.

► JavaScript Object Notation ( JSON) ist ein leichtes, textbasiertes, sprachunabhängiges Datenaustauschformat. JSON wurde verwendet, um Daten zwischen Anwendungen auszutauschen, die in einer beliebigen Programmiersprache geschrieben sind.

Das JSON-Objekt ist ein einzelnes Objekt, das zwei Funktionen enthält, parse und stringify, die zum Parsen und Erstellen von JSON-Texten verwendet werden.

• JSON.stringify erzeugt einen String, der der folgenden JSON-Grammatik entspricht.
• JSON.parse akzeptiert einen String, der der JSON-Grammatik entspricht.

Die parseJSON-Methode wird in die Fourth Edition of ECMAScript. In der Zwischenzeit ist eine JavaScript-Implementierung auf json.org verfügbar.

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 eine Teilmenge von JavaScript. Javascript wurde vom ECMAScript Programming Language Standard abgeleitet.

► ECMAScript

ECMAScript hat sich zu einer der weltweit am häufigsten verwendeten Allzweck-Programmiersprachen entwickelt. Es ist am besten als die in Webbrowsern eingebettete Sprache bekannt, wurde aber auch für Server- und eingebettete Anwendungen weit verbreitet. ECMAScript basiert auf mehreren Ursprungs-Technologien, von denen die bekannteste JavaScript(Netscape Communications) undJScript (Microsoft Corporation) sind . Obwohl ECMA vor 1994 als "European Computer Manufacturers Association" bekannt war, wurde nach 1994, als die Organisation global wurde, die "Marke" "Ecma" aus historischen Gründen beibehalten.

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

Dialekte wurden aus derselben Sprache abgeleitet. Sie sind einander ziemlich ähnlich, da sie aus derselben Sprache stammen, aber einige Änderungen erfahren haben. Ein Dialekt ist eine Variation in der Sprache selbst. Es ist aus einer einzigen Sprache abgeleitet.

• SQL-Sprache - MySQL-Dialekt im Ruhezustand, Oracle-Dialekt usw., die einige Änderungen oder zusätzliche Funktionen aufweisen.

Informationen über den Browser und den Computer Ihrer Benutzer.

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. Ausgabe von ECMAScript nicht veröffentlicht, da die Arbeit unvollständig war .

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

1. ► Schlüsselwerte müssen in Anführungszeichen gesetzt werden. Für Schlüssel sind nur Zeichenfolgen zulässig. Wenn Sie einen anderen als String verwenden, wird dieser in String konvertiert. Es wird jedoch nicht empfohlen, andere Schlüssel als die von String zu verwenden. Überprüfen Sie ein Beispiel wie dieses - { 'key':'val' }vorbeiRFC 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() {}' ] );

2. ► JSON-Zeichenfolgen müssen mit "und nicht" in Anführungszeichen gesetzt werden. Eine Zeichenfolge ähnelt stark einer C- oder Java-Zeichenfolge. Zeichenfolgen sollten in doppelte Anführungszeichen gesetzt werden.

   • Literale sind feste Werte, keine Variablen, die Sie buchstäblich in Ihrem Skript angeben.
   • Eine Zeichenfolge ist eine Folge von null oder mehr Zeichen, die in Anführungszeichen mit Backslash-Hemmung gesetzt sind. Dies ist die gleiche Notation, die in den meisten Programmiersprachen verwendet wird.
     • 🔫 - Spezielle Symbole sind in Zeichenfolgen zulässig, werden jedoch nicht zur Verwendung empfohlen.
     • \ "- Sonderzeichen können maskiert werden. Es wird jedoch nicht empfohlen, (') einfache Anführungszeichen zu maskieren. Im strengen Modus werden Fehler und Fehler ausgelöst. SyntaxError: Unexpected token ' in JSON

   Überprüfen Sie mit diesem Code { "Hai\" \n Team 🔫":5, "Bye \'": 7 }über Online-JSON-Editionen.ModesnotStrict,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"}

Objekt Eigenschaftenaccessoren ermöglicht den Zugriff auf die Eigenschaften eines Objekts durch die Punktnotation oder die Klammer - Notation.

3. ► Sie haben einen begrenzten Wertebereich (zB keine Funktionen erlaubt). Ein Wert kann eine Zeichenfolge in doppelten Anführungszeichen, Zahl, Boolescher Wert, Null, 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"}

► JavaScriptist die beliebteste Implementierung des ECMAScript-Standards. Die Hauptfunktionen von Javascript basieren auf dem ECMAScript-Standard, aber Javascript verfügt auch über andere zusätzliche Funktionen, die nicht in den ECMA-Spezifikationen / -Standards enthalten sind. Jeder Browser verfügt über einen JavaScript-Interpreter.

JavaScript ist eine dynamisch typisierte Sprache. Das heißt, Sie müssen den Datentyp einer Variablen nicht angeben, wenn Sie sie deklarieren, und die Datentypen werden bei Bedarf während der Skriptausführung automatisch konvertiert.

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 wird als ein Paar geschweifter Klammern dargestellt, die null oder mehr Name / Wert-Paare (oder Elemente) umgeben. Ein Name ist eine Zeichenfolge. Nach jedem Namen steht ein einzelner Doppelpunkt, der den Namen vom Wert trennt. Ein einzelnes Komma trennt einen Wert von einem folgenden Namen. Die Namen innerhalb eines Objekts sollten eindeutig sein.

ECMAScript unterstützt die prototypbasierte Vererbung. Jedem Konstruktor ist ein Prototyp zugeordnet, und jedem von diesem Konstruktor erstellten Objekt ist ein impliziter Verweis auf den Prototyp (als Prototyp des Objekts bezeichnet) zugeordnet, der seinem Konstruktor zugeordnet ist. Darüber hinaus kann ein Prototyp einen impliziten Verweis ungleich Null auf seinen Prototyp haben und so weiter; Dies wird als Prototypkette bezeichnet.

In einer klassenbasierten objektorientierten Sprache wird der Status im Allgemeinen von Instanzen übertragen, Methoden werden von Klassen übertragen, und die Vererbung erfolgt nur über Struktur und Verhalten. In ECMAScript werden der Status und die Methoden von Objekten übertragen, und Struktur, Verhalten und Status werden alle vererbt.

Ein Prototyp ist ein Objekt, mit dem die Vererbung von Struktur, Status und Verhalten in ECMAScript implementiert wird. Wenn ein Konstruktor ein Objekt erstellt, verweist dieses Objekt implizit auf den zugehörigen Prototyp des Konstruktors, um Eigenschaftsreferenzen aufzulösen. Auf den dem Konstruktor zugeordneten Prototyp kann durch den Programmausdruck constructor.prototype verwiesen werden, und Eigenschaften, die dem Prototyp eines Objekts hinzugefügt wurden, werden durch Vererbung von allen Objekten gemeinsam genutzt, die den Prototyp gemeinsam nutzen.

Für diejenigen, die immer noch der Meinung sind, dass RFC wichtiger ist als Blogs und meinungsbasierte Missverständnisse, versuchen wir, einige Punkte zu klären. Ich werde nicht alle korrekten Unterschiede wiederholen, die bereits in früheren Antworten erwähnt wurden. Hier versuche ich nur, einen Mehrwert zu schaffen, indem ich einen entscheidenden Teil rfc7159 zusammenfasse

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

1. JavaScript Object Notation (JSON) ist ein Textformat für die Serialisierung strukturierter Daten. Es wird vom Objekt abgeleitet von JavaScript abgeleitet, wie sie im ECMAScript Programming Language Standard, Dritte Ausgabe [ECMA-262] definiert sind.
2. JSON kann vier primitive Typen (Zeichenfolgen, Zahlen, Boolesche Werte und Null) und zwei strukturierte Typen ( Objekte) darstellen und Arrays) darstellen.
3. Ein Objekt ist eine ungeordnete Sammlung von null oder mehr Name / Wert-Paaren, wobei ein Name eine Zeichenfolge und ein Wert eine Zeichenfolge, eine Zahl, ein Boolescher Wert, eine Null, ein Objekt oder ein Array ist.
4. begin-object = ws% x7B ws; {linke geschweifte Klammer
5. Endobjekt = ws% x7D ws; } rechte geschweifte Klammer
6. Ein JSON-Wert MUSS ein Objekt , ein Array, eine Zahl oder eine Zeichenfolge oder einer der folgenden drei Literalnamen sein: false null true
7. Eine Objektstruktur wird als ein Paar geschweifter Klammern dargestellt
8. Die Namen innerhalb eines Objekts sollten eindeutig sein. object = begin-object [member * (Werttrennzeichen member)] end-object
9. Ein Objekt, dessen Namen alle eindeutig sind, ist in dem Sinne interoperabel, dass alle Softwareimplementierungen, die dieses Objekt empfangen, sich auf die Namens-Wert-Zuordnungen einigen. Wenn die Namen innerhalb eines Objekts nicht eindeutig sind, ist das Verhalten von Software, die ein solches Objekt empfängt, nicht vorhersehbar.

10. Beispiele (ab Seite 12 von 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]
              }
          }

    Das Image-Member ist ein Objekt, dessen Thumbnail-Member ein Objekt und dessen IDs-Member ein Array von Zahlen ist.

Es gibt wirklich kein "JSON-Objekt".

"Ja wirklich?"

Soweit ich weiß, ist der Hauptunterschied die Flexibilität .

JSON ist eine Art Wrapper für "JavaScript Object Notation", der Benutzer dazu zwingt, strengere Regeln für die Definition der Objekte einzuhalten. Dazu werden die möglichen Möglichkeiten zur Objektdeklaration eingeschränkt, die von der JavaScript-Objektnotationsfunktion bereitgestellt werden.

Als Ergebnis haben wir einfachere und standardisiertere Objekte, die sich besser für den Datenaustausch zwischen Plattformen eignen.

Im Grunde genommen ist das newObject in meinem obigen Beispiel ein Objekt, das mithilfe der JavaScript-Objektnotation definiert wurde. Es ist jedoch kein 'gültiges' JSON-Objekt, da es nicht den Regeln entspricht, die JSON-Standards erfordern.

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

Zuerst sollten Sie wissen, was JSON ist:

Es ist ein sprachunabhängiges Datenaustauschformat. Die Syntax von JSON wurde von der JavaScript Object Literal-Notation inspiriert, es gibt jedoch Unterschiede zwischen ihnen.

In JSON müssen beispielsweise alle Schlüssel in Anführungszeichen gesetzt werden, während dies in Objektliteralen nicht erforderlich ist:

// JSON: {"foo": "bar"}

// Objektliteral: var o = {foo: "bar"}; Die Anführungszeichen sind in JSON obligatorisch, da in JavaScript (genauer in ECMAScript 3rd Edition) die Verwendung reservierter Wörter als Eigenschaftsnamen nicht zulässig ist, z. B.:

var o = {if: "foo"}; // SyntaxError in ES3 Während die Verwendung eines Zeichenfolgenliteral als Eigenschaftsname (unter Angabe des Eigenschaftsnamens) keine Probleme verursacht:

var o = {"if": "foo"}; Aus Gründen der "Kompatibilität" (und vielleicht einer einfachen Bewertung?) Sind die Anführungszeichen obligatorisch.

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

Zeichenfolgenummer Objektarray Ein Literal wie folgt: true false null Die Grammatik von Zeichenfolgen ändert sich. Sie müssen durch doppelte Anführungszeichen begrenzt werden, während Sie in JavaScript einfache oder doppelte Anführungszeichen austauschbar verwenden können.

// Ungültiger JSON: {"foo": 'bar'} Die akzeptierte JSON-Grammatik von Zahlen ändert sich ebenfalls. In JavaScript können Sie hexadezimale Literale verwenden, z. B. 0xFF, oder (die berüchtigten) Oktalliterale, z. B. 010. In JSON können Sie verwenden nur Dezimalliterale.

// Ungültiger JSON: {"foo": 0xFF}

Javascript Object Literal vs JSON:

• Die Objektliteral-Syntax ist eine sehr bequeme Methode zum Erstellen von Javascript-Objekten
• Die JSONSyntax der Sprache, die für 'Javascript-Objektnotation' steht, leitet sich von der Literal-Syntax des Javascript-Objekts ab. Es wird als programmiersprachenunabhängiges Textdatenübertragungsformat verwendet.

Beispiel:

JS-Objektnotation, die in JS verwendet wird, um Objekte im Code bequem zu erstellen:

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 für 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;"
    }
}}

Hauptunterschiede:

• Alle Objektschlüssel in JSON müssen Zeichenfolgen sein. In Javascript können Objektschlüssel Zeichenfolgen oder Zahlen sein

• Alle Zeichenfolgen in JSON müssen in doppelte Anführungszeichen gesetzt werden. Während in Javascript sowohl einfache als auch doppelte Anführungszeichen zulässig sind. Auch ohne Anführungszeichen in der Javascript-Objektnotation werden die Objektschlüssel implizit in Zeichenfolgen umgewandelt.

• In JSON kann eine Funktion nicht als Wert eines Objekts definiert werden (da dies Javascript-spezifisch ist). In Javascript ist dies völlig legal.

Javascript eingebautes JSONObjekt:

JSONObjekte können mithilfe des integrierten JSONObjekts, das Javascript zur Laufzeit anbietet , problemlos in Javascript konvertiert werden und umgekehrt . Beispielsweise:

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

Hier ist ein überraschender Unterschied: Sie können nicht undefinedin json verwenden und alle Objektfelder mit undefinierten Werten verschwinden danachJSON.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) );

🙈🙉🙊