¿Alguien puede decirme cuál es la principal diferencia entre un objeto JavaScript definido mediante el uso de la notación literal de objetos y el objeto JSON ?

Según un libro de JavaScript, dice que este es un objeto definido mediante la notación de objetos :

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

¿Por qué no es un objeto JSON en este caso? ¿Solo porque no se define mediante comillas?

Primero aclaremos qué es JSON en realidad. JSON es un formato de intercambio de datos textual e independiente del idioma, muy parecido a XML, CSV o YAML.

Los datos pueden almacenarse de muchas maneras, pero si deben almacenarse en un archivo de texto y ser legibles por una computadora, deben seguir alguna estructura. JSON es uno de los muchos formatos que definen dicha estructura.

Tales formatos son típicamente independientes del lenguaje, lo que significa que pueden ser procesados ​​por Java, Python, JavaScript, PHP, lo que sea.

Por el contrario, JavaScript es un lenguaje de programación. Por supuesto, JavaScript también proporciona una forma de definir / describir datos, pero la sintaxis es muy específica de JavaScript.

Como contraejemplo, Python tiene el concepto de tuplas , su sintaxis es (x, y). JavaScript no tiene algo como esto.

Veamos las diferencias sintácticas entre los literales de objetos JSON y JavaScript.

JSON tiene las siguientes restricciones sintácticas:

• Las claves de objeto deben ser cadenas (es decir, una secuencia de caracteres entre comillas dobles ").
• Los valores pueden ser:
  • una cuerda
  • un número
  • un objeto (JSON)
  • una matriz
  • true
  • false
  • null
• Las claves duplicadas ( {"foo":"bar","foo":"baz"}) producen resultados indefinidos específicos de la implementación; la especificación JSON específicamente no define su semántica

En JavaScript, los literales de objeto pueden tener

• Literales de cadena, literales de números o nombres de identificadores como claves (desde ES6, las claves ahora también se pueden calcular, lo que introduce otra sintaxis).
• Los valores pueden ser cualquier expresión de JavaScript válida, incluidas las definiciones de función y undefined.
• Las claves duplicadas producen resultados definidos y especificados (en modo suelto, la última definición reemplaza a la anterior; en modo estricto, es un error).

Sabiendo que, simplemente mirando la sintaxis , su ejemplo no es JSON debido a dos razones:

1. Sus claves no son cadenas (literales). Son nombres identificadores .
2. No puede asignar una función como valor a un "objeto JSON" (porque JSON no define ninguna sintaxis para las funciones).

Pero lo más importante, para repetir mi explicación desde el principio: estás en un contexto de JavaScript. Usted define un objeto JavaScript. Si hay alguno, un "objeto JSON" solo puede estar contenido en una cadena:

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

Es decir, si está escribiendo código fuente JavaScript y no está tratando con una cadena , no está tratando con JSON. Tal vez recibió los datos como JSON (por ejemplo, a través de ajax o leyendo un archivo), pero una vez que usted o la biblioteca que está utilizando lo ha analizado, ya no es JSON.

Sólo porque literales de objetos y JSON se ven similares , que no quiere decir que usted puede nombrar indistintamente. Consulte también No existe tal cosa como un "Objeto JSON" .

JSON tiene una sintaxis mucho más limitada que incluye:

• Los valores clave deben ser citados
• Las cadenas deben estar entre comillas "y no'
• Tiene un rango de valores más limitado (por ejemplo, no se permiten funciones)

Realmente no existe tal cosa como un "Objeto JSON".

La especificación JSON es una sintaxis para codificar datos como una cadena. Lo que la gente llama un "Objeto JSON" (en javascript) es en realidad un objeto javascript ordinario que (probablemente) se ha deserializado de una cadena JSON válida, y se puede volver a serializar fácilmente como una cadena JSON válida. Esto generalmente significa que contiene solo datos (y no funciones). También significa que no hay fechas, porque JSON no tiene un tipo de fecha (probablemente lo más doloroso de JSON;)

Además, cuando se habla de un "Objeto JSON", casi siempre se refieren a datos que tienen "llaves" en el nivel superior. Esto corresponde muy bien a un objeto javascript. Sin embargo, la especificación JSON no requiere que haya un solo objeto "llaves" en el nivel superior de una cadena JSON. Es perfectamente válido JSON tener una lista en el nivel superior, o incluso tener un solo valor. Entonces, si bien cada "Objeto JSON" corresponde a un JSON válido, ¡no todas las cadenas JSON válidas corresponden a lo que llamaríamos un "Objeto JSON"! (porque la cadena podría representar una lista o un valor atómico)

De acuerdo con JSON en JavaScript ,

JSON es un subconjunto de la notación literal de objetos de JavaScript.

En otras palabras, JSON válido también es notación literal de objeto JavaScript válido, pero no necesariamente al revés.

Además de leer la documentación , como sugirió @Filix King, también sugiero jugar con el validador JSON en línea JSONLint . Así es como aprendí que las claves de los objetos JSON deben ser cadenas.

🔫 JSON : la alternativa libre de grasa a XML

JSON ha sido ampliamente adoptado por personas que descubrieron que facilitaba mucho la producción de aplicaciones y servicios distribuidos. El tipo de medio oficial de Internet para JSON es application/json RFC 4627. Los nombres de archivo JSON usan la extensión .json.

► JavaScript Object Notation ( JSON) es un formato de intercambio de datos ligero, basado en texto e independiente del idioma. JSON se ha utilizado para intercambiar datos entre aplicaciones escritas en cualquier lenguaje de programación.

El objeto JSON es un objeto único que contiene dos funciones, analizar y stringify, que se utilizan para analizar y construir textos JSON.

• JSON.stringify produce una cadena que se ajusta a la siguiente gramática JSON.
• JSON.parse acepta una cadena que se ajusta a la gramática JSON.

El método parseJSON se incluirá en el Fourth Edition of ECMAScript. Mientras tanto, una implementación de JavaScript está disponible en 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 es un subconjunto de JavaScript. Javascript se deriva del estándar de lenguaje de programación ECMAScript.

► ECMAScript

ECMAScript se ha convertido en uno de los lenguajes de programación de propósito general más utilizados en el mundo. Es mejor conocido como el lenguaje integrado en los navegadores web, pero también se ha adoptado ampliamente para servidores y aplicaciones integradas. ECMAScript se basa en varias tecnologías de origen, el ser más conocido JavaScript(Netscape Communications)) y JScript(Microsoft Corporation) . Aunque antes de 1994, ECMA era conocida como "Asociación Europea de Fabricantes de Computadoras", después de 1994, cuando la organización se volvió global, la "marca registrada" "Ecma" se mantuvo por razones históricas.

ECMAScript es el lenguaje, mientras que JavaScript, JScript e incluso ActionScript se llaman "Dialects".

Los dialectos se han derivado del mismo idioma. Son bastante similares entre sí, ya que se derivan del mismo idioma pero han sufrido algunos cambios. Un dialecto es una variación en el lenguaje mismo. Se deriva de un solo idioma.

• Lenguaje SQL: Hibernate MySQL Dialect, Oracle Dialect, ... que tienen algunos cambios o funcionalidades adicionales.

Información sobre el navegador y la computadora de sus usuarios.

navigator.appName // "Netscape"

ECMAScript es el lenguaje de script que forma 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.

NOTA «La cuarta edición de ECMAScript no se publicó porque el trabajo estaba incompleto .

JSON define un pequeño conjunto de reglas de formato para la representación portátil de datos estructurados.

1. ► Los valores de las claves deben estar entre comillas, solo se permiten cadenas para las claves. Si usa otro que no sea String, se convertirá en String. Pero no se recomienda usar otras teclas que no sean String. Mira un ejemplo como este - { 'key':'val' }overRFC 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. ► Las cadenas JSON se deben citar con "y no '. Una cadena es muy parecida a una cadena C o Java. Las cadenas deben estar entre comillas dobles.

   • Los literales son valores fijos, no variables, que usted proporciona literalmente en su secuencia de comandos.
   • Una cadena es una secuencia de cero o más caracteres entre comillas con escape de barra invertida, la misma notación utilizada en la mayoría de los lenguajes de programación.
     • 🔫 - Se permiten símbolos especiales en String pero no se recomienda su uso.
     • \ "- Se pueden escapar caracteres especiales. Pero no se recomienda escapar (') Comillas simples. En modo estricto arrojará y Error - SyntaxError: Unexpected token ' in JSON

   Verifique con este código { "Hai\" \n Team 🔫":5, "Bye \'": 7 }sobre las Ediciones JSON en línea.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"}

Los accesores de propiedades de objeto proporcionan acceso a las propiedades de un objeto mediante la notación de puntos o la notación de corchetes.

3. ► Tiene un rango de valores más limitado (por ejemplo, no se permiten funciones). Un valor puede ser una cadena entre comillas dobles, número, booleano, nulo, objeto o matriz. Estas estructuras pueden estar anidadas.

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

► JavaScriptes la implementación más popular del Estándar ECMAScript. Las características principales de Javascript se basan en el estándar ECMAScript, pero Javascript también tiene otras características adicionales que no están en las especificaciones / estándar de ECMA. Cada navegador tiene un intérprete de JavaScript.

JavaScript es un lenguaje de tipo dinámico. Eso significa que no tiene que especificar el tipo de datos de una variable cuando la declara, y los tipos de datos se convierten automáticamente según sea necesario durante la ejecución del 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 estructura de objeto se representa como un par de llaves entre cero o más pares de nombre / valor (o miembros). Un nombre es una cadena. Después de cada nombre, aparecen dos puntos, que separan el nombre del valor. Una coma simple separa un valor del siguiente nombre. Los nombres dentro de un objeto DEBEN ser únicos.

ECMAScript admite herencia basada en prototipos. Cada constructor tiene un prototipo asociado, y cada objeto creado por ese constructor tiene una referencia implícita al prototipo (llamado prototipo del objeto) asociado con su constructor. Además, un prototipo puede tener una referencia implícita no nula a su prototipo, y así sucesivamente; Esto se llama la cadena prototipo.

En un lenguaje orientado a objetos basado en clases, en general, el estado es llevado por instancias, los métodos son llevados por clases, y la herencia es solo de estructura y comportamiento. En ECMAScript, el estado y los métodos son transportados por objetos, y la estructura, el comportamiento y el estado son todos heredados.

Un prototipo es un objeto utilizado para implementar la herencia de estructura, estado y comportamiento en ECMAScript. Cuando un constructor crea un objeto, ese objeto hace referencia implícita al prototipo asociado del constructor con el fin de resolver referencias de propiedad. El prototipo asociado al constructor puede ser referenciado por la expresión del programa constructor.prototype, y las propiedades agregadas al prototipo de un objeto son compartidas, a través de la herencia, por todos los objetos que comparten el prototipo.

Para aquellos que todavía piensan que los RFC son más importantes que los blogs y los conceptos erróneos basados ​​en la opinión, tratemos de responder aclarando algunos puntos. No voy a repetir todas las diferencias correctas ya mencionadas en respuestas anteriores, aquí solo estoy tratando de agregar valor resumiendo alguna parte crucial rfc7159

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

1. JavaScript Object Notation (JSON) es un formato de texto para la serialización de datos estructurados. Se deriva de los literales de objetos de JavaScript, tal como se define en el Estándar del lenguaje de programación ECMAScript, tercera edición [ECMA-262].
2. JSON puede representar cuatro tipos primitivos (cadenas, números, booleanos y nulos) y dos tipos estructurados ( objetos y matrices).
3. Un objeto es una colección desordenada de cero o más pares de nombre / valor, donde un nombre es una cadena y un valor es una cadena, número, booleano, nulo, objeto o matriz.
4. begin-object = ws% x7B ws; {soporte rizado izquierdo
5. objeto final = ws% x7D ws; } corchete derecho
6. Un valor JSON DEBE ser un objeto , matriz, número o cadena, o uno de los siguientes tres nombres literales: falso nulo verdadero
7. Una estructura de objeto se representa como un par de llaves
8. Los nombres dentro de un objeto DEBEN ser únicos. object = begin-object [member * (value-separator member)] end-object
9. Un objeto cuyos nombres son todos únicos es interoperable en el sentido de que todas las implementaciones de software que reciben ese objeto estarán de acuerdo en las asignaciones de nombre-valor. Cuando los nombres dentro de un objeto no son únicos, el comportamiento del software que recibe dicho objeto es impredecible.

10. Ejemplos (de la página 12 de RFC)

    Este es un objeto 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]
              }
          }

    Su miembro Image es un objeto cuyo miembro Thumbnail es un objeto y cuyo miembro ID es una matriz de números.

Realmente no existe tal cosa como un "Objeto JSON".

De Verdad?

Por lo que yo entiendo, la principal diferencia es la flexibilidad .

JSON es un tipo de contenedor en "JavaScript Object Notation" que obliga a los usuarios a obedecer reglas más estrictas para definir los objetos. Y lo hace limitando las posibles formas de declaración de objetos proporcionadas por la función de notación de objetos JavaScript.

Como resultado, tenemos objetos más simples y estandarizados que se adaptan mejor al intercambio de datos entre plataformas.

Básicamente, el nuevo objeto en mi ejemplo anterior es un objeto definido usando la notación de objeto de JavaScript; pero no es un objeto JSON 'válido' porque no sigue las reglas que requieren los estándares JSON.

Este enlace también es bastante útil: http://msdn.microsoft.com/en-us/library/bb299886.aspx

Primero debes saber qué es JSON:

Es un formato de intercambio de datos independiente del lenguaje. La sintaxis de JSON se inspiró en la notación literal de objetos de JavaScript, pero existen diferencias entre ellos.

Por ejemplo, en JSON se deben citar todas las claves, mientras que en los literales de objetos esto no es necesario:

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

// Objeto literal: var o = {foo: "bar"}; Las comillas son obligatorias en JSON porque en JavaScript (más exactamente en ECMAScript 3rd. Edition), el uso de palabras reservadas como nombres de propiedades no está permitido, por ejemplo:

var o = {if: "foo"}; // SyntaxError en ES3 Mientras, usar un literal de cadena como nombre de propiedad (citando el nombre de la propiedad) no da problemas:

var o = {"if": "foo"}; Entonces, para "compatibilidad" (¿y evaluación fácil, tal vez?), Las citas son obligatorias.

Los tipos de datos en JSON también están restringidos a los siguientes valores:

número de cadena matriz de objetos Un literal como: verdadero falso nulo La gramática de las cadenas cambia. Deben estar delimitados por comillas dobles, mientras que en JavaScript, puede usar comillas simples o dobles indistintamente.

// JSON no válido: {"foo": 'bar'} La gramática aceptada de Números de JSON también cambia, en JavaScript puedes usar Literales hexadecimales, por ejemplo 0xFF, o (los infames) Literales Octales, por ejemplo 010. En JSON puedes usar solo literales decimales.

// JSON no válido: {"foo": 0xFF}

Javascript Object Literal vs JSON:

• La sintaxis literal de objetos es una forma muy conveniente de crear objetos javascript
• El JSONlenguaje, que significa 'notación de objeto Javascript', tiene su sintaxis derivada de la sintaxis literal del objeto javascript. Se utiliza como un lenguaje de programación independiente del formato de transferencia de datos textuales.

Ejemplo:

Notación de objeto JS, utilizada en JS para crear objetos en el código convenientemente:

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
}

Ejemplo 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 diferencias:

• Todas las claves de objeto en JSON deben ser cadenas. En Javascript las claves de objeto pueden ser cadenas o números

• Todas las cadenas en JSON se deben citar en "comillas dobles". Mientras que en Javascript se permiten tanto comillas simples como comillas dobles. Incluso sin comillas en la notación de objetos Javascript, las claves de los objetos se convierten implícitamente en cadenas.

• En JSON, una función no se puede definir como un valor de un objeto (ya que esto es específico de Javascript). En Javascript esto es completamente legal.

Javascript construir en JSONobjeto:

JSONlos objetos se pueden convertir fácilmente a Javascript y viceversa utilizando el JSONobjeto incorporado que Javascript ofrece en su tiempo de ejecución. Por ejemplo:

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

Aquí hay una sorprendente diferencia: no se puede usar undefineden json y todos los campos de objetos con valores indefinidos desaparecerán despué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) );

🙈🙉🙊