Qual è la differenza tra JSON e Object Notation letterale?

https://stackoverflow.com/questions/2904131

04-10-2019
|

Domanda

Qualcuno può dirmi qual è la differenza principale tra un oggetto JavaScript definito utilizzando letterale oggetto Notation e oggetto JSON

Secondo un libro JavaScript si dice che questo è un oggetto definito utilizzando Object Notation :

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

Perché non si tratta di un oggetto JSON in questo caso? Solo perché non è definita utilizzando le virgolette?

Soluzione

Consente di chiarire prima cosa JSON in realtà è. JSON è un testuale , il formato dei dati-scambio linguistico-indepedent, molto simile a XML, CSV o YAML.

I dati possono essere memorizzati in molti modi, ma se deve essere conservato in un file di testo ed essere leggibile da un computer, ha bisogno di seguire una certa struttura. JSON è uno dei tanti formati che definiscono tale struttura a.

Tali formati sono in genere indipendente dal linguaggio, nel senso che possono essere elaborati da Java, Python, JavaScript, PHP, è il nome.

Al contrario, JavaScript è un linguaggio di programmazione. Naturalmente JavaScript fornisce anche un modo per definire / descrivere i dati, ma la sintassi è molto specifico per JavaScript.

Come esempio contatore, Python ha il concetto di tuple , la sintassi è (x, y). JavaScript non ha qualcosa di simile.

Vediamo le differenze sintattiche tra JSON e JavaScript letterali oggetto.

JSON ha i seguenti vincoli sintattici:

Oggetto i tasti deve essere stringhe (vale a dire una sequenza di caratteri racchiusa tra doppi apici ").
I valori possono essere:
- una stringa
- un numero
- un (JSON) oggetto
- un array
- true
- false
- null
chiavi duplicate ({"foo":"bar","foo":"baz"}) prodotti undefined, i risultati specifici di attuazione; la specifica JSON specificamente non definisce la loro semantica

In JavaScript, letterali oggetto può avere

Le stringhe, letterali numero o identificativo nome dei tasti (dal ES6, chiavi possono anche essere calcolati, che introduce l'ennesimo sintassi).
I valori possono essere qualsiasi espressione JavaScript valida, tra cui le definizioni di funzioni e undefined.
Chiavi duplicate produrre definito, risultati specificati (in modo allentato, quest'ultima definizione si sostituisce al precedente, in modo rigoroso, è un errore).

Sapendo che, basta essere guardando il sintassi , il tuo esempio non è JSON a causa di due motivi:

Le chiavi non sono stringhe letterali (). Essi sono identificatori .
Non è possibile assegnare una funzione come valore di un "oggetto JSON" (perché JSON non definisce alcuna sintassi per le funzioni).

Ma ancora più importante, di ripetere la mia spiegazione dall'inizio: Sei in un contesto JavaScript. Si definisce un oggetto JavaScript. Se del caso, un "oggetto JSON" può essere contenuta solo in una stringa:

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

Cioè, se si sta scrivendo JavaScript codice sorgente, e non si tratta di un stringa , non sei che fare con JSON. Forse hai ricevuto i dati come JSON (ad esempio, tramite la tecnologia AJAX o la lettura da un file), ma una volta o una libreria che si sta utilizzando ha analizzato, esso non è più JSON.

Solo a causa letterali oggetto JSON e sguardo simile , ciò non significa che è possibile assegnare un nome in modo intercambiabile Vedi anche non c'è cosa come un "JSON oggetto" .

Altri suggerimenti

JSON ha una sintassi molto più limitato tra cui:

I valori chiave deve essere citato
Le stringhe deve essere citato con " e non '
Si dispone di una gamma più limitata di valori (ad esempio, non funziona consentito)

Non c'è davvero una cosa come un "JSON oggetto".

Il JSON specifica è una sintassi per la codifica di dati come una stringa. Quello che la gente chiama un "JSON oggetto" (in javascript) è in realtà solo un oggetto javascript ordinario che ha (probabilmente) stato de-serializzato da una stringa JSON valida, e può essere facilmente ri-serializzato come stringa JSON valido. Questo generalmente significa che esso contiene solo i dati (e non funzioni). E significa anche che non ci sono date, perché JSON non ha un tipo di data (probabilmente la cosa più dolorosa circa JSON;)

Inoltre, (lato-sproloquio ...) quando si parla di un "JSON oggetto", quasi sempre dati significa che ha le "parentesi graffe" al livello superiore. Ciò corrisponde bene ad un oggetto JavaScript. Tuttavia, le specifiche JSON non richiede che vi sia un unico "parentesi graffe" dell'oggetto al primo livello di una stringa JSON. E 'perfettamente valido JSON per avere un elenco a livello di top, o anche di avere solo un singolo valore. Così, mentre ogni corrisponde "JSON oggetto" da validi JSON, non tutte le stringhe JSON validi corrispondono a quello che noi chiameremmo un "JSON oggetto"! (Perché la stringa potrebbe rappresentare un elenco o un valore atomico)

Secondo le JSON in JavaScript ,

JSON è un sottoinsieme dell'oggetto notazione letterale di JavaScript.

In altre parole, valida JSON è valido anche oggetto JavaScript notazione letterale, ma non necessariamente il contrario.

Oltre a leggere il documentazione , come suggerito @Filix re, ho anche suggerire a giocare con il < a href = "http://www.jsonlint.com/" rel = "noreferrer"> JSONLint linea JSON validatore . È così che ho imparato che le chiavi di oggetti JSON devono essere stringhe.

?? JSON : L'alternativa Fat-Free in XML

JSON è stato ampiamente adottato da persone che hanno trovato che ha reso molto più facile per la produzione di applicazioni e servizi distribuiti. Il tipo di supporto Internet ufficiale per JSON è application/json RFC 4627 . i nomi dei file JSON utilizzano il .json estensione.

? JavaScript Object Notation ( JSON ) è un peso leggero, basato su testo, scambio di dati indipendente dalla lingua formato. JSON è stato utilizzato per lo scambio di dati tra le applicazioni scritte in qualsiasi linguaggio di programmazione.

L'oggetto JSON è un oggetto singolo che contiene due funzioni, analizzare e stringa i, che vengono utilizzate per analizzare e costruire testi JSON.


JSON.stringify produce una stringa che è conforme alle seguenti grammatica JSON.

JSON.parse accetta una stringa che sia conforme alla grammatica JSON.


Il metodo parseJSON sarà incluso nella Fourth Edition of ECMAScript . Nel frattempo, un'implementazione JavaScript è disponibile presso json.org.

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 è sottoinsieme di JavaScript. Javascript è stato derivato dalla ECMAScript linguaggio di programmazione standard.

? ECMAScript

ECMAScript è cresciuto fino a essere uno dei linguaggi di programmazione general purpose più utilizzati al mondo. E 'meglio conosciuta come il linguaggio incorporato nei browser web, ma è anche stato ampiamente adottato per il server e le applicazioni embedded. ECMAScript è basato su diverse tecnologie originari, il più conosciuto è JavaScript (Netscape comunicazioni)) e JScript (Microsoft Corporation).) . Anche se prima del 1994, ECMA era conosciuto come "Associazione europea dei produttori di computer", dopo il 1994, quando l'organizzazione è diventata globale, il "marchio di fabbrica" ??"Ecma" è stato mantenuto per ragioni storiche.

ECMAScript è la lingua, mentre JavaScript, JScript, e anche ActionScript sono chiamati "Dialects" .

I dialetti sono stati derivato dalla stessa lingua. Essi sono sono abbastanza simili tra di loro in quanto sono stati derivati ??dalla stessa lingua ma hanno subito alcune modifiche.   Un dialetto è una variazione nella lingua stessa. È derivato da una sola lingua.


SQL Lingua -. Hibernate MySQL Dialetto, Oracle Dialetto, .. che hanno alcuni cambiamenti o funzionalità aggiuntive

Informazioni sul browser e il computer degli utenti.

navigator.appName // "Netscape"

ECMAScript è il linguaggio di scripting che costituisce la base di JavaScript. 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.

nota « 4a edizione di ECMAScript non pubblicato come il lavoro era incompleta .

JSON definisce un piccolo insieme di regole di formattazione per la rappresentazione di dati strutturati portatile.

? valori chiave devono essere quotati, solo le stringhe sono permessi per le chiavi. Se si utilizzano diversi da String verrà convertito a stringa. Ma non è raccomandato l'uso di tasti diversi stringa di. Controllare un esempio come questo - { 'key':'val' } oltre 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 stringhe deve essere citato con "e non'. Una stringa è molto simile a una stringa C o Java. Le stringhe deve essere avvolto tra virgolette.
- I valori letterali sono fisse, non variabili, che letteralmente forniscono nello script.
- Una stringa è una sequenza di zero o più caratteri avvolti in citazioni con backslash scappamento, la stessa notazione usata nella maggior parte dei linguaggi di programmazione.
  - ?? -. I simboli speciali sono ammessi in stringa ma non consigliato a uso
  - \" - Caratteri speciali può essere sfuggito, ma non consigliato a fuggire ( ') virgolette singole.. In modalità Strict si getterà and Error - SyntaxError: Unexpected token ' in JSON
Verificare con questo codice { "Hai\" \n Team 🔫":5, "Bye \'": 7 } corso on-line 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"}
```

proprietà di accesso fornire l'accesso alle proprietà di un oggetto utilizzando la notazione punto o la notazione staffa.

? Si dispone di una gamma più limitata di valori (ad esempio senza funzioni consentito). Un valore può essere una stringa in virgolette, numero, booleano, null, oggetto o array. Queste strutture possono essere nidificate.

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 è il più popolare applicazione di standard ECMAScript. Le caratteristiche principali di JavaScript sono basati sullo standard ECMAScript, ma JavaScript ha anche altre funzioni aggiuntive che non sono nelle specifiche ECMA / standard. Ogni browser ha un interprete JavaScript.

JavaScript è un linguaggio tipizzato in modo dinamico. Questo significa che non c'è bisogno di specificare il tipo di dati di una variabile quando si dichiara, e tipi di dati vengono convertiti automaticamente in base alle esigenze durante l'esecuzione dello script.

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

Struttura Un oggetto è representato come una coppia di staffe graffe circostanti zero o più coppie nome / valore (o membri). Un nome è un corda. Una singola colon viene dopo ogni nome, separando il nome dal valore. Una singola virgola separa un valore da un seguito nome. I nomi all'interno di un oggetto deve essere univoco.

ECMAScript supporta l'ereditarietà basata sui prototipi. Ogni costruttore ha un prototipo di associato, e ogni oggetto creato da quel costruttore ha un implicito riferimento al prototipo (chiamato dell'oggetto prototipo) associati con il suo costruttore. Inoltre, un prototipo può avere un non-nullo implicito riferimento al suo prototipo, e così via; questo è chiamato catena di prototipi.

In un oggetto linguaggio orientato di classe, in generale, lo stato è portato da istanze, metodi sono portati da classi ed ereditarietà è solo di struttura e comportamento. In ECMAScript, lo stato e metodi sono portati da oggetti, e la struttura, il comportamento e stato sono tutti ereditati.

Un prototipo è un oggetto utilizzato per implementare la struttura, lo stato e l'ereditarietà comportamento in ECMAScript. Quando un costruttore crea un oggetto, l'oggetto fa riferimento implicitamente prototipo associato del costruttore con lo scopo di risolvere i riferimenti di proprietà. Associated prototipo può del costruttore riferimento il constructor.prototype espressione programma e proprietà aggiunte con il prototipo di un oggetto sono condivise, per eredità, da tutti gli oggetti che condividono il prototipo.

Per quelli che ancora pensano che la RFC sono più importanti blog e idee sbagliate parere sulla base, proviamo a rispondere a chiarire alcuni punti. Non ho intenzione di ripetere tutte le differenze corrette già citati nelle risposte precedenti, qui sto solo cercando di valore aggiunto che riassume una parte cruciale rfc7159

https://tools.ietf.org/html/rfc7159

JavaScript Oggetto Notation (JSON) è un formato di testo per la serializzazione di dati strutturati. È derivato da oggetto letterali di JavaScript, come definiti nella programmazione ECMAScript Standard Lingue, terza edizione [ECMA-262].
JSON può rappresentare quattro tipi primitivi (stringhe, numeri, booleani, e nullo) e due tipi strutturati ( oggetti e array).
Un oggetto è una collezione non ordinata di zero o più nome / valore coppie, in cui un nome è una stringa e un valore è una stringa, numero, boolean, null, oggetto , o matrice.
cominciare-oggetto = ws% x7B ws; {Sinistra parentesi graffa
end-oggetto = ws% x7D ws; } Destra parentesi graffa
Un valore JSON deve essere un oggetto , matrice, numero o stringa, o uno dei i seguenti tre nomi letterali: falso nullo true
Un oggetto struttura è rappresentato come una coppia di staffe graffe
I nomi all'interno di un oggetto deve essere univoco. oggetto = cominciare-oggetto [membro * (membro valore-separatore)] end-oggetto
Un oggetto i cui nomi sono tutti unici è interoperabile nel senso che tutte le implementazioni del software di ricezione che oggetto concorderanno le mappature nome-valore. Quando i nomi all'interno di un oggetto non sono unico, il comportamento del software che riceve come un oggetto è imprevedibile.

Gli esempi (da pagina 12 del RFC)

Questo è un oggetto JSON:

      {
        "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]
          }
      }

Il suo membro immagine è un oggetto il cui membro Miniatura è un oggetto e il cui elemento ID è un array di numeri.

Non c'è davvero una cosa come una "JSON oggetto".

Davvero?

Per quanto ho capito la differenza principale è la flessibilità .

JSON è una sorta di involucro su "JavaScript Object Notation", che impone agli utenti di obbedire regole più severe per la definizione degli oggetti. E lo fa, limitando i possibili modi di dichiarazione oggetto forniti da JavaScript Object Notation funzione.

Come risultato abbiamo un oggetti più semplici e standardizzati, che meglio si adatta ai dati di scambio tra le piattaforme.

Quindi, in pratica, il newObject nel mio esempio di cui sopra è un oggetto definito utilizzando JavaScript Objeect Notation; ma non è una 'valida' oggetto JSON, perché non segue le regole che gli standard JSON richiedono.

Questo link è anche molto utile: http://msdn.microsoft.com/en-us/library/bb299886. aspx

In primo luogo si dovrebbe sapere cosa JSON è:

E 'la lingua agnostico-formato di dati di interscambio. La sintassi di JSON è stato ispirato dal oggetto JavaScript letterale notazione, ma ci sono differenze tra di loro.

Per esempio, in JSON tutte le chiavi devono essere citato, mentre in letterali oggetto non è necessario:

// JSON: { "Pippo": "bar"}

// Oggetto letterale: var o = {foo: "bar"}; Le virgolette sono obbligatorie in JSON, perché in JavaScript (. Più precisamente in ECMAScript 3rd Edition), l'utilizzo di parole riservate come nomi di proprietà non è consentita, ad esempio:

var o = {IF: "pippo"}; // SyntaxError in ES3 Mentre, utilizzando un letterale stringa come un nome di proprietà (citando il nome di proprietà) non dà problemi:

var o = { "se": "pippo"}; Così per "compatibilità" (e facile eval'ing forse?) Le virgolette sono obbligatori.

I tipi di dati in JSON sono anche limitata ai seguenti valori:

stringa numero oggetto Vettore Un letterale come: vero falso nullo La grammatica della stringhe cambia. Essi devono essere delimitati da virgolette doppie, mentre in JavaScript, è possibile utilizzare le virgolette singole o doppie in modo intercambiabile.

// non valido JSON: { "Pippo": 'bar'} Il JSON grammatica dei numeri accettato cambia anche, in JavaScript è possibile utilizzare esadecimali letterali, ad esempio 0xFF, o (il famigerato) letterali Octal esempio 010. In JSON è possibile utilizzare solo decimale letterali.

// non valido JSON: { "Pippo": 0xFF}

JavaScript Object letterale vs JSON:

la sintassi letterale oggetto è un modo molto conveniente per creare oggetti JavaScript
Il linguaggio JSON, che sta per 'JavaScript Object Notation', ha la sua sintassi derivata dalla sintassi letterale oggetto JavaScript. È usato come un linguaggio di programmazione formato di trasferimento dati testuali indipendenti.

Esempio:

JS Object Notation, utilizzato in JS per creare oggetti nel codice comodamente:

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
}

Esempio di 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;"
    }
}}

differenze principali:

Tutte le chiavi oggetto di JSON devono essere stringhe. In Javascript chiavi oggetto possono essere stringhe o numeri
Tutte le stringhe in JSON deve essere citato in "virgolette". Considerando che Javascript sia virgolette singole e doppie virgolette sono ammessi. Anche senza le virgolette in oggetto Javascript notazione le chiavi oggetto sono implicitamente casted in stringhe.
In JSON una funzione non può essere definito come un valore di un oggetto (poiché questo è JavaScript specifico). In Javascript questo è completamente legale.

JavaScript costruire in oggetto JSON:

oggetti JSON possono essere facilmente convertiti in JavaScript e viceversa utilizzando incorporato nell'oggetto JSON cui JavaScript offerte nella sua esecuzione. Ad esempio:

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

Ecco una differenza sorprendente: non è possibile utilizzare undefined in JSON e tutti i campi degli oggetti con valori non definiti scompare dopo 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) );

??????

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow