en JSON, ¿por qué se cita cada nombre?

La especificación JSON dice que JSON es un objeto o una matriz. En el caso de un objeto,

Una estructura de objeto se representa como un par de llaves que rodean cero o más pares de nombre / valor (o miembros). Un nombre es una cadena. ...

Y luego, la especificación dice que una cadena está entre comillas.

¿Por qué?

Así,

{"Property1":"Value1","Property2":18}

y no

{Property1:"Value1",Property2:18}

Pregunta 1 : ¿por qué no permitir que el nombre en los pares de nombre / valor sean identificadores sin comillas?

Pregunta 2 : ¿Existe una diferencia semántica entre las dos representaciones anteriores, cuando se evalúan en Javascript?

Pregunta 1: ¿por qué no permitir que el nombre en los pares de nombre / valor sean identificadores sin comillas?

La filosofía de diseño de JSON es "Keep it simple"

"Citar nombres con "" es mucho más simple que "Puede citar nombres con "o, 'pero no es necesario, a menos que contengan ciertos caracteres (o combinaciones de caracteres que lo convertirían en una palabra clave) 'o es "posible que deba citarse según en el delimitador que seleccionó " .

Pregunta 2: ¿Existe una diferencia semántica entre las dos representaciones anteriores, cuando se evalúan en Javascript?

No. En JavaScript son idénticos.

Les dejo una cita de una presentación que Douglas Crockford (el creador del estándar JSON) le dio a Yahoo.

Habla sobre cómo descubrió JSON y, entre otras cosas, por qué decidió usar claves entre comillas :

.... Fue entonces cuando descubrimos el problema de los nombres sin comillas. Resulta que ECMA Script 3 tiene una política de palabras reservadas. Las palabras reservadas deben citarse en la posición clave, lo que realmente es una molestia. Cuando llegué a formular esto en un estándar, no quería tener que poner todas las palabras reservadas en el estándar, porque se vería realmente estúpido.

En ese momento, estaba tratando de convencer a la gente: sí, puedes escribir aplicaciones en JavaScript, realmente va a funcionar y es un buen lenguaje. No quería decir, entonces, al mismo tiempo: ¡y mire esta cosa realmente estúpida que hicieron! Así que decidí, en cambio, citar las claves.
De esa manera, no tenemos que decirle a nadie qué tan bueno es.

Es por eso que, hasta el día de hoy, las claves se cotizan en JSON.

Puede encontrar el video completo y la transcripción aquí .

:Se permiten tanto los espacios en blanco como los identificadores. Sin las comillas, esto causaría ambigüedad al intentar determinar qué constituye exactamente el identificador.

En javascript, los objetos se pueden usar como una tabla hash / hash con pares de claves.

Sin embargo, si su clave tiene caracteres que javascript no podría convertir en un nombre, fallaría al intentar acceder como una propiedad en un objeto en lugar de una clave.

var test  = {};
test["key"] = 1;
test["#my-div"] = "<div> stuff </div>";

// test = { "key": 1, "#my-div": "<div> stuff </div>" };

console.log(test.key);           // should be 1
console.log(test["key"]);        // should be 1
console.log(test["#my-div"]);    // should be "<div> stuff </div>";
console.log(test.#my-div);       // would not work.

Los identificadores a veces pueden tener caracteres que no se pueden evaluar como token / identificador en javascript, por lo tanto, es mejor poner todos los identificadores en cadenas para mantener la coherencia.

Creo que la respuesta correcta a la pregunta de Cheeso es que la implementación superó la documentación. Ya no requiere una cadena como clave, sino algo más, que puede ser una cadena (es decir, entre comillas) o (probablemente) cualquier cosa que se pueda usar como nombre de variable, lo que supongo que significa comenzar con una letra, _ , o $, e incluya solo letras, números y $ y _.

Quería simplificar el resto para la próxima persona que visite esta pregunta con la misma idea que yo. Aquí está la carne:

Los nombres de las variables no se interpolan en JSON cuando se usan como clave de objeto (¡Gracias Friedo!)

Breton, utilizando "identificador" en lugar de "clave", escribió que "si un identificador es una palabra reservada, se interpreta como esa palabra en lugar de como un identificador". Esto puede ser cierto, pero lo intenté sin ningún problema:

var a = {do:1,long:2,super:3,abstract:4,var:5,break:6,boolean:7};
a.break

=> 6

Sobre el uso de comillas, Quentin escribió "... pero no es necesario, a menos que [la clave] contenga ciertos caracteres (o combinaciones de caracteres que la convertirían en una palabra clave)".

Encontré que la parte anterior (ciertos caracteres) es verdadera, usando el signo @ (de hecho, creo que $ y _ son los únicos caracteres que no causan el error):

var a = {a@b:1};

=> Error de sintaxis

var a = {"a@b":1};
a['a@b']

=> 1

pero el paréntesis sobre las palabras clave, como mostré anteriormente, no es cierto.

Lo que quería funciona porque el texto entre la apertura {y los dos puntos, o entre la coma y los dos puntos para las propiedades posteriores se usa como una cadena sin comillas para hacer una clave de objeto, o, como dijo Friedo, un nombre de variable no lo hace ' t se interpola:

var uid = getUID();
var token = getToken();            // Returns ABC123
var data = {uid:uid,token:token};
data.token

=> ABC123

Si json describe objetos, en la práctica obtienes lo siguiente

var foo = {};

var bar = 1;

foo["bar"] = "hello";
foo[bar] = "goodbye";

por lo que entonces,

foo.bar == "hello";
foo[1] == "goodbye" // in setting it used the value of var bar

por lo que incluso si sus ejemplos producen el mismo resultado, sus equivalentes en "código sin formato" no lo harían. ¿¿Tal vez por eso?? no sé, sólo una idea.

Puede reducir el tamaño de los datos si las comillas en el nombre solo se permiten cuando sea necesario