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

Selon un livre JavaScript, il s'agit d'un objet défini à l'aide de la notation d'objet :

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

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

Permet de clarifier d'abord ce qu'est réellement JSON . JSON est un format d'échange de données textuel et indépendant de la langue, tout comme XML, CSV ou YAML.

Les données peuvent être stockées de plusieurs manières, mais si elles doivent être stockées dans un fichier texte et être lisibles par un ordinateur, elles doivent suivre une certaine structure. JSON est l'un des nombreux formats qui définissent une telle structure.

Ces formats sont généralement indépendants du langage, ce qui signifie qu'ils peuvent être traités par Java, Python, JavaScript, PHP, vous l'appelez.

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

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

Regardons les différences syntaxiques entre les littéraux d'objets JSON et JavaScript.

JSON a les contraintes syntaxiques suivantes:

• Les clés d' objet doivent être des chaînes (c'est-à-dire une séquence de caractères entre guillemets ").
• Les valeurs peuvent être soit:
  • un string
  • un numéro
  • un objet (JSON)
  • un tableau
  • true
  • false
  • null
• Les clés en double ( {"foo":"bar","foo":"baz"}) produisent des résultats non définis et spécifiques à l'implémentation; la spécification JSON ne définit pas spécifiquement leur sémantique

En JavaScript, les littéraux d'objet peuvent avoir

• Les littéraux de chaîne, les littéraux de nombre ou les noms d'identifiants sous forme de clés (depuis ES6, les clés peuvent désormais également être calculées, ce qui introduit une autre syntaxe).
• Les valeurs peuvent être n'importe quelle expression JavaScript valide, y compris les définitions de fonction et undefined.
• Les clés en double produisent des résultats définis et spécifiés (en mode lâche, la dernière définition remplace la première; en mode strict, c'est une erreur).

Sachant que, juste en regardant la syntaxe , votre exemple n'est pas JSON pour deux raisons:

1. Vos clés ne sont pas des chaînes (littérales). Ce sont des noms d'identifiants .
2. Vous ne pouvez pas affecter une fonction en tant que valeur à un "objet JSON" (car JSON ne définit aucune syntaxe pour les fonctions).

Mais surtout, pour répéter mon explication depuis 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 que 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 traitez pas avec une chaîne , vous ne traitez pas avec JSON. Peut-être que vous avez reçu les données en JSON (par exemple, via ajax ou en lisant un fichier), mais une fois que vous ou une bibliothèque que vous utilisez les a analysées, ce n'est plus du JSON.

Ce n'est pas parce que les littéraux d'objet et JSON se ressemblent que cela signifie que vous pouvez les nommer de manière interchangeable. Voir aussi Il n'y a rien de tel qu'un "objet JSON" .

JSON a une syntaxe beaucoup plus limitée, notamment:

• Les valeurs clés doivent être indiquées
• Les chaînes doivent être citées avec "et non'
• Vous avez une plage de valeurs plus limitée (par exemple, aucune fonction n'est autorisée)

Il n'y a vraiment rien de tel qu'un "objet JSON".

La spécification JSON est une syntaxe pour coder les données sous forme de chaîne. Ce que les gens appellent un "objet JSON" (en javascript) est vraiment juste un objet javascript ordinaire qui a (probablement) été désérialisé à partir 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 non des fonctions). Cela signifie également qu'il n'y a pas de dates, car JSON n'a pas de type de date (probablement la chose la plus douloureuse à propos de JSON;)

De plus, (side-rant ...) quand les gens parlent d'un "objet JSON", ils signifient presque toujours des données qui ont les "accolades" au niveau supérieur. Cela correspond bien à un objet javascript. Cependant, la spécification JSON n'exige pas qu'il existe un seul objet "accolades" au niveau supérieur d'une chaîne JSON. Il est parfaitement valide pour JSON d'avoir une liste au niveau supérieur, ou même de n'avoir qu'une seule valeur. Ainsi, alors que chaque "objet JSON" correspond à un JSON valide, toutes les chaînes JSON valides ne correspondent pas à ce que nous appellerions un "objet JSON"! (car la chaîne pourrait représenter une liste ou une valeur atomique)

Selon JSON en JavaScript ,

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

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

En plus de lire la documentation , comme l'a suggéré @Filix King, je suggère également de jouer avec le validateur JSON en ligne JSONLint . C'est ainsi que j'ai appris que les clés des objets JSON doivent être des chaînes.

🔫 JSON : l'alternative sans gras au XML

JSON a été largement adopté par les personnes qui ont découvert qu'il facilitait la production d'applications et de services distribués. Le type de média Internet officiel pour JSON est application/json RFC 4627. Les noms de fichiers JSON utilisent l'extension .json.

► JavaScript Object Notation ( JSON) est un format d'échange de données léger, basé sur du texte et indépendant du langage. JSON a été utilisé pour échanger des données entre des applications écrites dans n'importe quel langage de programmation.

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

• JSON.stringify produit une chaîne conforme à la grammaire JSON suivante.
• JSON.parse accepte une chaîne conforme à la grammaire JSON.

La méthode parseJSON sera incluse dans le Fourth Edition of ECMAScript. En attendant, une implémentation JavaScript est disponible sur 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 un sous-ensemble de JavaScript. Javascript est dérivé de la norme de langage de programmation ECMAScript.

► ECMAScript

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

ECMAScript est le langage, tandis que JavaScript, JScript et même ActionScript sont appelés "Dialects".

Les dialectes sont dérivés de la même langue. Ils sont assez similaires les uns aux autres car ils sont dérivés de la même langue mais ils ont subi quelques changements. Un dialecte est une variation de la langue elle-même. Il est dérivé d'une seule langue.

• Langage SQL - Hibernate MySQL Dialect, Oracle Dialect, .. qui ont quelques changements ou fonctionnalités ajoutées.

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

navigator.appName // "Netscape"

ECMAScript est le langage de script qui constitue 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 d'ECMAScript non publiée car l'ouvrage était incomplet .

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

1. ► Les valeurs de clé doivent être citées, seules les chaînes sont autorisées pour les clés. Si vous utilisez autre que String, il sera converti en String. Mais il n'est pas recommandé d'utiliser des clés autres que celles de String. Vérifiez un exemple comme celui-ci - { 'key':'val' }terminé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() {}' ] );

2. ► Les chaînes JSON doivent être entre guillemets "et non". Une chaîne ressemble beaucoup à une chaîne C ou Java. Les chaînes doivent être entourées de guillemets doubles.

   • Les littéraux sont des valeurs fixes, pas des variables, que vous fournissez littéralement dans votre script.
   • Une chaîne est une séquence de zéro ou plusieurs caractères entourés de guillemets avec échappement antislash, 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 ne sont pas recommandés à utiliser.
     • \ "- Les caractères spéciaux peuvent être échappés. Mais il n'est pas recommandé d'échapper (') les guillemets 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 les éditions JSON en ligne.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"}

Les accesseurs de propriété d' objet permettent d'accéder aux propriétés d'un objet en utilisant la notation par points ou la notation par crochets.

3. ► Vous avez une plage de valeurs plus limitée (par exemple, aucune fonction n'est autorisée). Une valeur peut être une chaîne entre guillemets doubles, 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"}

► JavaScriptest l'implémentation la plus populaire de la norme ECMAScript. Les fonctionnalités principales de Javascript sont basées sur la norme ECMAScript, mais Javascript possède également d'autres fonctionnalités supplémentaires qui ne figurent pas dans les spécifications / normes ECMA. Chaque navigateur possède un interpréteur JavaScript.

JavaScript est un langage typé dynamiquement. Cela signifie que vous n'avez pas besoin de spécifier le type de données d'une variable lorsque vous la déclarez, et les types de données sont convertis automatiquement selon les besoins pendant 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

Une structure d'objet est représentée comme une paire de crochets entourant zéro ou plusieurs paires nom / valeur (ou membres). Un nom est une chaîne. Un deux-points vient après chaque nom, séparant le nom de la valeur. Une seule virgule sépare une valeur d'un nom suivant. Les noms dans un objet DEVRAIENT être uniques.

ECMAScript prend en charge 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é prototype de l'objet) associé à son constructeur. En outre, un prototype peut avoir une référence implicite non nulle à son prototype, etc. c'est ce qu'on appelle la chaîne prototype.

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

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

Pour ceux qui pensent toujours que la RFC est plus importante que les blogs et les idées fausses basées sur l'opinion, essayons de répondre en clarifiant 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 j'essaie simplement d'ajouter de la valeur résumant une partie cruciale rfc7159

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

1. La notation d' objet JavaScript (JSON) est un format texte pour la sérialisation des données structurées. Il est dérivé des littéraux d' objets de JavaScript, tels que définis dans la norme ECMAScript Programming Language Standard, troisième édition [ECMA-262].
2. JSON peut représenter quatre types primitifs (chaînes, nombres, booléens et null) et deux types structurés ( objets et tableaux).
3. Un objet est une collection non ordonnée de zéro ou plusieurs paires nom / valeur, où un nom est une chaîne et une valeur est une chaîne, un nombre, un booléen, une valeur nulle, un objet ou un tableau.
4. begin-object = ws% x7B ws; {accolade gauche
5. objet final = ws% x7D ws; } accolade droite
6. Une valeur JSON DOIT être un objet , un tableau, un nombre ou une chaîne, ou l'un des trois noms littéraux suivants: false null true
7. Une structure d' objet est représentée par une paire de crochets
8. Les noms dans un objet DEVRAIENT être uniques. objet = objet -début [membre * (membre séparateur de valeurs)] objet-fin
9. Un objet dont les noms sont tous uniques est interopérable dans le sens où toutes les implémentations logicielles recevant cet objet seront d'accord sur les mappages nom-valeur. Lorsque les noms d'un objet ne sont pas uniques, le comportement du logiciel qui reçoit un tel objet est imprévisible.

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

    Il s'agit d'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 Image est un objet dont le membre Thumbnail est un objet et dont le membre IDs est un tableau de nombres.

Il n'y a vraiment rien de tel qu'un "objet JSON".

Vraiment?

Autant que je sache, la principale différence est la flexibilité .

JSON est une sorte de wrapper sur "JavaScript Object Notation" qui oblige les utilisateurs à obéir à des règles plus strictes pour définir les objets. Et il le fait en limitant les possibilités de déclaration d'objet fournies par la fonction JavaScript Object Notation.

En conséquence, nous avons des objets plus simples et plus standardisés qui conviennent mieux à l'échange de données entre plates-formes.

Donc, fondamentalement, le newObject dans mon exemple ci-dessus est un objet défini en utilisant la notation d'objet JavaScript; mais ce n'est pas un objet JSON «valide» car il ne suit pas les règles requises par les normes JSON.

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

Vous devez d'abord savoir ce qu'est JSON:

Il s'agit d'un format d'échange de données indépendant de la langue. La syntaxe de JSON a été inspirée par la notation JavaScript Object Literal, mais il existe des différences entre elles.

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

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

// Littéral d'objet: var o = {foo: "bar"}; Les guillemets sont obligatoires sur JSON car en JavaScript (plus exactement dans ECMAScript 3rd. Edition), l'utilisation de mots réservés comme noms de propriété est interdite, par exemple:

var o = {if: "foo"}; // SyntaxError dans ES3 Alors que l'utilisation d'un littéral de chaîne comme nom de propriété (en citant le nom de la propriété) ne pose aucun problème:

var o = {"if": "foo"}; Donc pour la "compatibilité" (et l'évaluation facile peut-être?), Les devis sont obligatoires.

Les types de données dans JSON sont également limités aux valeurs suivantes:

tableau d'objets numéro de chaîne Un littéral comme: true false null La grammaire de Strings change. Ils doivent être délimités par des guillemets doubles, tandis qu'en JavaScript, vous pouvez utiliser des guillemets simples ou doubles de manière interchangeable.

// JSON non valide: {"foo": 'bar'} La grammaire JSON acceptée des nombres change également, en JavaScript, vous pouvez utiliser des littéraux hexadécimaux, par exemple 0xFF, ou (les tristement célèbres) octaux littéraux, par exemple 010. En JSON, vous pouvez utiliser uniquement les littéraux décimaux.

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

Javascript Object Literal vs JSON:

• La syntaxe littérale des objets est un moyen très pratique de créer des objets javascript
• Le JSONlangage, qui signifie «notation d'objet Javascript», a sa syntaxe dérivée de la syntaxe littérale de l'objet javascript. Il est utilisé comme format de transfert de données textuelles indépendant du langage de programmation.

Exemple:

Notation d'objet JS, utilisée dans JS pour créer facilement des objets dans le code:

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

Différences principales:

• Toutes les clés d'objet en JSON doivent être des chaînes. En Javascript, les clés d'objet peuvent être des chaînes ou des nombres

• Toutes les chaînes en JSON doivent être entre guillemets. Alors qu'en Javascript, les guillemets simples et doubles sont autorisés. Même sans guillemets dans la notation d'objet Javascript, les clés d'objet sont implicitement converties en chaînes.

• En JSON, une fonction ne peut pas être définie comme une valeur d'un objet (car c'est spécifique à Javascript). En Javascript, c'est complètement légal.

Javascript construit dans l' JSONobjet:

JSONles objets peuvent être facilement convertis en Javascript et vice versa en utilisant l' JSONobjet intégré que Javascript propose dans son runtime. 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 undefineddans json et tous les champs d'objet avec des valeurs non définies disparaîtront aprèsJSON.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) );

🙈🙉🙊