Quelle est la différence entre JSON et Object Notation littérales?

https://stackoverflow.com/questions/2904131

04-10-2019
|

Question

Quelqu'un peut-il me dire quelle est la principale différence entre un objet JavaScript défini en utilisant Object Notation littérales et objet JSON

Selon un livre JavaScript il dit ceci est un objet défini en utilisant Object Notation :

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

Pourquoi est-ce pas un objet JSON dans ce cas? Tout simplement parce que ce n'est pas définie en utilisant des guillemets?

La solution

Permet de préciser d'abord ce que JSON est en réalité. JSON est un textuelle , la langue indepedent le format d'échange de données, un peu comme XML, CSV ou YAML.

Les données peuvent être stockées à bien des égards, mais si elle doit être stocké dans un fichier texte et être lisible par un ordinateur, il doit suivre une certaine structure. JSON est l'un des nombreux formats qui définissent la structure d'un tel.

Ces formats sont généralement indépendants de la langue, ce qui signifie qu'ils peuvent être traités par Java, Python, JavaScript, PHP, vous le nom.

En revanche, JavaScript est un langage de programmation. Bien sûr, JavaScript fournit également un moyen de définir / décrire les données, mais la syntaxe est très spécifique à JavaScript.

Par contre exemple, Python a le concept de tuples , leur syntaxe est (x, y). JavaScript n'a pas quelque chose comme ça.

permet de regarder les différences entre syntaxiques littéraux objet JSON et JavaScript.

JSON a les contraintes syntaxiques suivantes:

Objet touches doit être chaînes (par exemple une séquence de caractères entre guillemets doubles ").
Les valeurs peuvent être:
- une chaîne
- un certain nombre
- un objet (JSON)
- un tableau
- true
- false
- null
Double des clés ({"foo":"bar","foo":"baz"}) produits non défini, les résultats spécifiques à la mise en œuvre; la spécification JSON ne définit pas spécifiquement leur sémantique

En JavaScript, littéraux objet peut avoir

littéraux de chaîne, littérales ou numéro identifiant des noms comme clés (depuis ES6, les clés peuvent désormais être calculés, qui introduit une autre syntaxe).
Les valeurs peuvent être toute expression JavaScript valide, y compris les définitions de fonction et undefined.
clés en double production définies, les résultats spécifiés (en mode libre, cette dernière définition remplace l'ancien, en mode strict, il est une erreur).

Sachant que, juste être regardant la syntaxe , votre exemple n'est pas JSON à cause de deux raisons:

Vos clés ne sont pas des chaînes (littéraux). Ils sont noms d'identificateurs .
Vous ne pouvez pas attribuer une fonction en tant que valeur à un « objet JSON » (parce que JSON ne définit pas la syntaxe pour les fonctions).

Mais le plus important, de répéter mon explication dès le début: Vous êtes dans un contexte JavaScript. Vous définissez un objet JavaScript. Le cas échéant, un « objet JSON » ne peut être contenu dans une chaîne:

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

Autrement dit, si vous écrivez du code source JavaScript, et ne pas traiter avec string , vous ne vous occupez pas de JSON. Peut-être que vous avez reçu les données JSON (par exemple, via ajax ou la lecture d'un fichier), mais une fois que vous ou une bibliothèque que vous utilisez ont analysé, ce n'est pas JSON plus.

Seulement parce que littéraux objet et regard JSON similaires , cela ne signifie pas que vous pouvez les nommer de façon interchangeable Voir aussi Il n'y a pas une telle chose comme un " JSON de l'objet".

Autres conseils

JSON a une syntaxe beaucoup plus limitée, y compris:

Les valeurs clés doivent être cité
Les chaînes doivent être indiqués avec " et non '
Vous avez une gamme plus limitée de valeurs (par exemple pas de fonction autorisée)

Il n'y a vraiment pas une telle chose comme un "objet JSON".

La spécification JSON est une syntaxe pour coder des données sous forme de chaîne. Ce que les gens appellent un « JSON Object » (en javascript) est vraiment un objet javascript ordinaire qui a (probablement) été désérialisé d'une chaîne JSON valide et peut être facilement re-sérialisé comme une chaîne JSON valide. Cela signifie généralement qu'il ne contient que des données (et pas de fonctions). Il a également signifie qu'il n'y a pas de dates, car JSON ne dispose pas d'un type de date (probablement la plus douloureuse chose au sujet JSON;)

En outre, (côté diatribe ...) quand les gens parlent d'un « objet JSON », ils ont presque toujours des données moyennes qui a les « accolades » au plus haut niveau. Ceci correspond bien à un objet javascript. Cependant, la spécification JSON ne nécessite pas qu'il y ait un seul « accolades » objet au niveau supérieur d'une chaîne JSON. Il est tout à fait valable JSON d'avoir une liste au plus haut niveau, ou même d'avoir juste une seule valeur. Ainsi, alors que tous les « JSON objet » correspond à valide JSON, toutes les chaînes de JSON valides correspondent à ce que nous appelons un « objet JSON »! (Parce que la chaîne pourrait représenter une liste ou d'une valeur atomique)

JSON en JavaScript ,

JSON est un sous-ensemble de l'objet notation littérale de JavaScript.

En d'autres termes, JSON valide est également objet JavaScript valide notation littérale, mais pas nécessairement l'inverse.

En plus de lire de documentation, comme @Filix roi suggéré, je suggère aussi jouer avec le < a href = "http://www.jsonlint.com/" rel = "noreferrer"> JSONLint en ligne JSON validateur . Voilà comment j'appris que les clés d'objets JSON doivent être des chaînes.

?? JSON : L'alternative sans gras au format XML

JSON a été largement adopté par les gens qui ont trouvé qu'il fait beaucoup plus facile de produire des applications et des services distribués. Le type de média Internet officiel pour JSON est application/json RFC 4627 . JSON noms de fichiers utilisent l'extension .json.

? JavaScript Object Notation ( JSON ) est un poids léger, à base de texte, l'échange de données indépendant de la langue format. JSON a été utilisé pour échanger des données entre les applications écrites dans un langage de programmation.

L'objet JSON est un objet unique qui contient deux fonctions, analyser et stringify, qui sont utilisés pour analyser et construire des textes JSON.


JSON.stringify produit une chaîne conforme à la grammaire JSON suivant.

JSON.parse accepte une chaîne qui est conforme à la grammaire JSON.


La méthode parseJSON sera inclus dans le Fourth Edition of ECMAScript . En attendant, une mise en œuvre JavaScript est disponible à 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 est sous-ensemble de JavaScript. Javascript provient de la programmation ECMAScript langue standard.

? ECMAScript

ECMAScript a grandi pour devenir l'un des plus utilisés dans le monde des langages de programmation à usage général. Il est surtout connu comme le langage intégré dans les navigateurs Web, mais a également été largement adopté pour le serveur et les applications embarquées. ECMAScript est basée sur plusieurs technologies originaires, le plus connu étant JavaScript (Netscape communications)) et JScript (Microsoft Corporation).) . Bien avant 1994, ECMA était connu comme « l'Association européenne des fabricants d'ordinateur », après 1994, lorsque l'organisation est devenue mondiale, la « marque » « Ecma » a été conservé pour des raisons historiques.

ECMAScript est la langue, alors que JavaScript, JScript, et même ActionScript sont appelés "Dialects" .

Dialects ont dérivé de la même langue. Ils sont sont assez semblables les uns aux autres comme ils ont été tirés de la même langue, mais ils ont subi quelques changements.   Un dialecte est une variation dans la langue elle-même. Il est dérivé d'une seule langue.


Language SQL -. Mise en veille prolongée MySQL Dialect, Oracle Dialect, .. qui ont des changements ou des fonctionnalités supplémentaires

Informations sur le navigateur et l'ordinateur de vos utilisateurs.

navigator.appName // "Netscape"

ECMAScript est le langage de script qui forme la base de 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.

NOTE « 4ème édition de ECMAScript pas publié que le travail était incomplet .

JSON définit un petit ensemble de règles de formatage pour la représentation portable des données structurées.

? Les valeurs clés doivent être citées, seules les chaînes sont autorisés pour les clés. Si vous utilisez un autre de chaîne, il sera converti en chaîne. Mais pas recommandé d'utiliser des clés autres que chaîne de. Consultez un exemple comme celui-ci - { 'key':'val' } sur 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 doit être cité avec "et non ». Chaîne A est très semblable à une chaîne C ou Java. Les chaînes doivent être enveloppé dans des guillemets doubles.
- littéraux sont des valeurs fixes et non variables que vous fournissez littéralement dans votre script.
- Une chaîne est une séquence de zéro ou plusieurs caractères entre guillemets avec échappement à barre oblique inverse, la même notation utilisée dans la plupart des langages de programmation.
  - ?? -. Les symboles spéciaux sont autorisés dans la chaîne, mais pas recomended utiliser
  - \ » - Les caractères spéciaux peuvent être échappé mais pas pour échapper (recomended ') Citations simples.. En mode strict, il lancera et erreur - SyntaxError: Unexpected token ' in JSON
Vérifiez avec ce code { "Hai\" \n Team 🔫":5, "Bye \'": 7 } sur ligne 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"}
```

propriété fournir un accès accès, à l' pour les propriétés d'un objet en utilisant la notation par points ou la notation de support.

? Vous avez une plage de valeurs plus limitées (par exemple aucune fonction autorisée). Une valeur peut être une chaîne entre guillemets, nombre, booléen, null, objet ou tableau. Ces structures peuvent être imbriquées.

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 est le plus populaire de mise en œuvre la norme ECMAScript. Les caractéristiques de base de Javascript sont basés sur la norme ECMAScript, mais Javascript a aussi d'autres fonctionnalités supplémentaires qui ne sont pas dans les spécifications ECMA / standard. Chaque navigateur a un interpréteur JavaScript.

JavaScript est un langage typé dynamiquement. Cela signifie que vous ne devez pas spécifier le type de données d'une variable lorsque vous déclarez, et les types de données sont automatiquement converties au besoin lors de l'exécution du 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

Structure Un objet est représenté comme une paire d'accolades autour de zéro ou plusieurs paires nom / valeur (ou des membres). Un nom est chaîne. Un colon unique vient après chaque nom, à séparer le nom de la valeur. Une virgule sépare une valeur à partir d'une suite Nom. Les noms dans un objet doit être unique.

ECMAScript supporte l'héritage basé sur un prototype. Chaque constructeur a un prototype associé, et chaque objet créé par ce constructeur a une référence implicite au prototype (appelé l'objet de prototype) associé à son constructeur. En outre, un prototype peut avoir une référence implicite non nul à son prototype, et ainsi de suite; ce qu'on appelle la chaîne de prototype.

Dans un langage orienté objet de classe, en général, l'état est porté par cas, les méthodes sont portés par les classes et l'héritage est que la structure et le comportement. En ECMAScript, l'état et les méthodes sont portées par des objets, et la structure, le comportement et l'état sont tous hérités.

Un prototype est un objet utilisé pour mettre en œuvre la structure, l'état et le comportement de transmission dans ECMAScript. Lorsqu'un constructeur crée un objet, cet objet fait référence implicitement prototype associé du constructeur dans le but de résoudre les références de propriété. prototype associé du constructeur peut être référencé par le constructor.prototype d'expression du programme, et les propriétés ajoutées au prototype d'un objet sont partagés, par héritage, par tous les objets qui partagent le prototype.

Pour ceux qui pensent encore que la RFC sont plus importants que les blogs et les idées fausses sur la base d'opinion, nous allons essayer de répondre à clarifier certains points. Je ne vais pas répéter toutes les différences correctes déjà mentionnées dans les réponses précédentes, ici, je suis juste essayer valeur ajoutée qui résume une partie cruciale rfc7159

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

JavaScript Objet Notation (JSON) est un format de texte pour la sérialisation de données structurées. Il est dérivé de l'objet littéraux de JavaScript, tels que définis dans la programmation ECMAScript Standard Langue, Troisième édition [ECMA-262].
JSON peut représenter quatre types primitifs (chaînes, nombres, booléens, et null) et deux types structurés ( Objets et tableaux).
Objet est une collection non ordonnée de zéro ou plusieurs nom / valeur paires, où un nom est une chaîne et une valeur est une chaîne, le nombre, boolean, null, objet , ou un tableau.
commencer objet = ws% X7B ws; {Accolade gauche
fin objet = ws ws% x7D; } Accolade droite
Une valeur JSON DOIT être un objet , un tableau, un nombre ou une chaîne ou une de les trois noms littéraux suivants: null false true
Objet structure est représentée comme une paire de accolades
Les noms dans un objet doit être unique. objet = commencer objet [* élément (élément séparateur valeur)] fin objet
Objet dont les noms sont tous est interopérable dans le sens unique de que toutes les implémentations de logiciels recevant que objet seront d'accord sur les correspondances nom-valeur. Lorsque les noms dans un objet ne sont pas unique, le comportement du logiciel qui reçoit un tel objet est imprévisible.

Exemples (à partir de la page 12 de la RFC)

Ceci est un objet 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] } }

Son membre d'image est un objet dont le membre miniature est un objet dont l'organe d'ID est un tableau de nombres.

Il n'y a vraiment pas une telle chose comme un « objet JSON ».

Vraiment?

Pour autant que je comprends la différence principale est le flexibilité .

JSON est une sorte d'emballage sur « JavaScript Object Notation » que les utilisateurs des forces d'obéir à des règles plus strictes pour définir les objets. Et il le fait en limitant les moyens de déclaration d'objets possibles fournies par JavaScript Object Notation fonction.

Par conséquent, nous avons un des objets plus simples et plus standardisés qui convient le mieux sur l'échange de données entre plates-formes.

Donc, fondamentalement, le newObject dans mon exemple ci-dessus est un objet défini en utilisant JavaScript Objeect notation; mais il est pas « valide » objet JSON, car il ne respecte pas les règles que les normes exigent JSON.

Ce lien est également très utile: http://msdn.microsoft.com/en-us/library/bb299886. aspx

D'abord, vous devez savoir ce que JSON est:

Il est la langue agnostique format d'échange de données. La syntaxe de JSON a été inspiré par la notation littérales JavaScript Object, mais il y a des différences entre eux.

Par exemple, JSON toutes les clés doivent être cité, tandis que dans littéraux objet ce n'est pas nécessaire:

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

// littéral d'objet: var o = {foo: "bar"}; Les citations sont obligatoires sur JSON car en JavaScript (. Plus exactement dans ECMAScript 3e édition), l'usage des mots réservés comme noms de propriété est pas autorisée, par exemple:

var o = {if: "foo"}; // SyntaxError dans ES3 Alors que, en utilisant un littéral de chaîne comme un nom de propriété (en indiquant le nom de la propriété) donne aucun problème:

var o = { "si": "foo"}; Donc, pour la « compatibilité » (et eval'ing facile peut-être?) Les guillemets sont obligatoires.

Les types de données dans JSON sont également limitées aux valeurs suivantes:
chaîne
nombre objet tableau Un littéral comme: vrai faux nul La grammaire de change Strings. Ils doivent être délimités par des guillemets, tout en JavaScript, vous pouvez utiliser des guillemets simples ou doubles de manière interchangeable.

// non valide JSON: { "Foo": 'bar'} La grammaire acceptée JSON des nombres change aussi, en JavaScript, vous pouvez utiliser hexadécimaux littéraux, par exemple 0xFF, ou (l'infâme) littéraux Octal par exemple 010. En JSON vous ne pouvez utiliser que décimales littéraux.

// non valide JSON: { "Foo": 0xFF}

Javascript Object littérales vs JSON:

syntaxe littéral d'objet est un moyen très pratique pour créer des objets javascript

La langue JSON, qui signifie « notation objet JavaScript », a sa syntaxe dérivée de l'objet javascript syntaxe littérale. Il est utilisé comme un langage de programmation indépendant du format de transfert de données textuelles.

Exemple:

notation objet JS, JS utilisé dans la création d'objets dans le code commodément:

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 }

Exemple de 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;" } }}

Principales différences:

Toutes les clés d'objet dans JSON doivent être des chaînes. Dans les clés d'objets Javascript peuvent être des chaînes ou des chiffres

Toutes les chaînes JSON doit être cité dans « guillemets ». Alors que dans les deux Javascript guillemets simples et doubles guillemets sont autorisés. Même sans guillemets dans l'objet Javascript notation des clés d'objets sont implicitement casté en chaînes.

Dans JSON une fonction ne peut pas être définie comme une valeur d'un objet (puisque c'est spécifique Javascript). En Javascript cela est tout à fait légal.

Javascript construire en objet JSON:

Les objets de JSON peuvent être facilement convertis en Javascript et vice-versa en utilisant le haut dans l'objet JSON qui offre Javascript dans son exécution. Par exemple:

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

Voici une différence surprenante: vous ne pouvez pas utiliser undefined dans JSON et tous les champs d'objet avec des valeurs non définies disparaissent après 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) );

??????

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow