🔫 JSON : l'alternativa senza grassi a XML
JSON è stato ampiamente adottato da persone che hanno scoperto che rendeva molto più semplice produrre applicazioni e servizi distribuiti. Il tipo di supporto Internet ufficiale per JSON è application/json RFC 4627. I nomi di file JSON utilizzano l'estensione .json.
► JavaScript Object Notation ( JSON) è un formato di scambio dati leggero, basato su testo e indipendente dalla lingua. JSON è stato utilizzato per scambiare dati tra applicazioni scritte in qualsiasi linguaggio di programmazione.
L'oggetto JSON è un singolo oggetto che contiene due funzioni, analisi e stringify, utilizzate per analizzare e costruire testi JSON.
- JSON.stringify produce una stringa conforme alla seguente grammatica JSON.
- JSON.parse accetta una stringa conforme alla grammatica JSON.
Il metodo parseJSON sarà incluso in Fourth Edition of ECMAScript. Nel frattempo, un'implementazione JavaScript è disponibile su 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 è un sottoinsieme di JavaScript. Javascript è stato derivato dallo standard del linguaggio di programmazione ECMAScript.
► ECMAScript
ECMAScript è cresciuto fino a diventare uno dei linguaggi di programmazione per scopi generici più utilizzati al mondo. È meglio conosciuto come il linguaggio incorporato nei browser Web, ma è stato anche ampiamente adottato per server e applicazioni integrate. ECMAScript si basa su diverse tecnologie di origine, l'essere più noto JavaScript(Netscape Communications)) e JScript(Microsoft Corporation).) . Sebbene prima del 1994, l'ECMA era conosciuta come "European Computer Manufacturers Association", dopo il 1994, quando l'organizzazione divenne globale, il "marchio" "Ecma" è stato mantenuto per ragioni storiche.
ECMAScript è il linguaggio, mentre vengono chiamati JavaScript, JScript e persino ActionScript "Dialects".
I dialetti sono stati derivati dalla stessa lingua. Sono abbastanza simili tra loro in quanto derivati dalla stessa lingua ma hanno subito alcuni cambiamenti. Un dialetto è una variazione della lingua stessa. Deriva da una sola lingua.
- Linguaggio SQL: ibernazione dialetto MySQL, dialetto Oracle, .. che presentano alcune modifiche o funzionalità aggiuntive.
Informazioni sul browser e sul computer dei tuoi 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 «La 4a edizione di ECMAScript non è stata pubblicata perché l'opera era incompleta .
JSON definisce un piccolo set di regole di formattazione per la rappresentazione portatile di dati strutturati.
► I valori delle chiavi devono essere indicati, solo le stringhe sono consentite per le chiavi. Se si utilizza diverso da String, verrà convertito in String. Ma non è consigliabile utilizzare chiavi diverse da quelle di String. Controlla un esempio come questo - { 'key':'val' }finitoRFC 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() {}' ] );
► Le stringhe JSON devono essere citate con "e non". Una stringa è molto simile a una stringa C o Java. Le stringhe devono essere racchiuse tra virgolette doppie.
- I letterali sono valori fissi, non variabili, che letteralmente fornisci nella tua sceneggiatura.
- Una stringa è una sequenza di zero o più caratteri racchiusi tra virgolette con scappamento a barra rovesciata, la stessa notazione utilizzata nella maggior parte dei linguaggi di programmazione.
- 🔫 - I simboli speciali sono consentiti in String ma non è consigliato l'uso.
- \ "- I caratteri speciali possono essere salvati. Ma non è consigliato scappare (') Virgolette singole. In modalità Strict genererà ed Errore -
SyntaxError: Unexpected token ' in JSON
Verificare con questo codice { "Hai\" \n Team 🔫":5, "Bye \'": 7 }tramite le edizioni JSON online.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"}
Gli accessor Proprietà oggetto forniscono l'accesso alle proprietà di un oggetto usando la notazione punto o la parentesi.
► È disponibile un intervallo di valori più limitato (ad es. Nessuna funzione consentita). Un valore può essere una stringa tra virgolette, numero, valore booleano, null, oggetto o matrice. 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è l'implementazione più popolare dello standard ECMAScript. Le funzionalità principali di Javascript si basano sullo standard ECMAScript, ma Javascript ha anche altre funzionalità aggiuntive che non sono nelle specifiche / standard ECMA. Ogni browser ha un interprete JavaScript.
JavaScript è un linguaggio tipizzato in modo dinamico. Ciò significa che non è necessario specificare il tipo di dati di una variabile quando la si dichiara e i tipi di dati vengono convertiti automaticamente quando necessario 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
Una struttura di oggetti è rappresentata come una coppia di parentesi graffe che circondano zero o più coppie nome / valore (o membri). Un nome è una stringa. Un singolo punto viene dopo ogni nome, separando il nome dal valore. Una singola virgola separa un valore dal seguente nome. I nomi all'interno di un oggetto DOVREBBERO essere univoci.
ECMAScript supporta l'ereditarietà basata su prototipi. Ogni costruttore ha un prototipo associato e ogni oggetto creato da quel costruttore ha un riferimento implicito al prototipo (chiamato prototipo dell'oggetto) associato al suo costruttore. Inoltre, un prototipo può avere un riferimento implicito non nullo al suo prototipo e così via; questa si chiama catena prototipo.
In un linguaggio orientato agli oggetti basato sulla classe, in generale, lo stato è trasportato da istanze, i metodi sono trasportati da classi e l'eredità è solo di struttura e comportamento. In ECMAScript, lo stato e i metodi sono trasportati da oggetti e la struttura, il comportamento e lo stato sono tutti ereditati.
Un prototipo è un oggetto utilizzato per implementare l'ereditarietà di struttura, stato e comportamento in ECMAScript. Quando un costruttore crea un oggetto, quell'oggetto fa implicitamente riferimento al prototipo associato del costruttore allo scopo di risolvere i riferimenti di proprietà. Il prototipo associato del costruttore può essere referenziato dall'espressione del programma constructor.prototype e le proprietà aggiunte al prototipo di un oggetto sono condivise, tramite ereditarietà, da tutti gli oggetti che condividono il prototipo.