javascript - mostrar - ¿Cuál es la diferencia entre JSON y Object Literal Notation?

mostrar datos json javascript

Question

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

Según un libro de JavaScript, dice que este es un objeto definido mediante el uso de 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?

Answer 1

Aclaremos primero qué es JSON realidad. JSON es un formato de intercambio de datos textual , independiente del idioma, como XML, CSV o YAML.

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

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

En contraste, 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 para JavaScript.

Como ejemplo de contador, 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 los objetos 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 y específicos de la implementación; La especificación JSON específicamente no define su semántica

En JavaScript, los literales de objetos pueden tener

• Literales de cadena, números literales 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 válida de JavaScript, incluidas las definiciones de funciones y undefined .
• Las claves duplicadas producen resultados definidos y especificados (en modo suelto, la última definición reemplaza al primero; en modo estricto, es un error).

Sabiendo eso, solo mirando la sintaxis , su ejemplo no es JSON debido a dos razones:

1. Tus llaves no son cuerdas (literales). Son nombres identificadores .
2. No puede asignar una función como un 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. Se define un objeto de 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 el código fuente de 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 lectura de un archivo), pero una vez que usted o una biblioteca que está utilizando lo analizan, ya no es JSON.

Solo porque los literales de objetos y JSON tienen un aspecto similar , no significa que pueda nombrarlos indistintamente. Ver también No hay tal cosa como un "objeto JSON" .

Answer 2

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

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

1. La notación de objetos de JavaScript (JSON) es un formato de texto para la serialización de datos estructurados. Se deriva de los literales de objetos de JavaScript, como se define en el Estándar de Lenguaje de Programación ECMAScript, Tercera Edición [ECMA-262].
2. JSON puede representar cuatro tipos primitivos (cadenas, números, valores 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; {corchete 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. objeto = objeto -inicial [miembro * (miembro separador de valor)] objeto-final
9. Un objeto cuyos nombres son todos únicos es interoperable en el sentido de que todas las implementaciones de software que reciban ese objeto coincidirán en las asignaciones de nombre-valor. Cuando los nombres dentro de un objeto no son únicos, el comportamiento del software que recibe tal 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 de imagen es un objeto cuyo miembro en miniatura es un objeto y cuyo miembro de ID es una matriz de números.

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

De Verdad?

Answer 3

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

JSON es un tipo de envoltorio de "Notación de objetos de JavaScript" 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 de JavaScript.

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

Básicamente, el newObject en mi ejemplo anterior es un objeto definido mediante el uso de la notación de objeect 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 muy útil: http://msdn.microsoft.com/en-us/library/bb299886.aspx

Answer 4

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 del objeto JavaScript, pero existen diferencias entre ellos.

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

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

// Objeto literal: var o = {foo: "bar"}; Las citas 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 la "compatibilidad" (¿y fácil evaluación?) Las citas son obligatorias.

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

string number object array Un literal como: verdadero falso nulo Cambia la gramática de las cadenas. Deben estar delimitados por comillas dobles, mientras que en JavaScript, puede usar comillas simples o dobles de manera intercambiable.

// JSON no válido: {"foo": ''bar''} La gramática JSON aceptada de Numbers también cambia, en JavaScript puede usar literales hexadecimales, por ejemplo 0xFF, o (los infames) literales octales, por ejemplo, 010. En JSON, puede usar Sólo literales decimales.

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

Answer 5

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 solo un objeto javascript ordinario que (probablemente) ha sido 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 solo contiene 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 las "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 que JSON tenga una lista en el nivel superior, o incluso que tenga un solo valor. Entonces, mientras 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)

Answer 6

Según JSON en JavaScript ,

JSON es un subset de la notación literal de objeto de JavaScript.

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

Además de leer la JSON , 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.

Answer 7

🔫 JSON : La alternativa libre de grasa a XML

JSON ha sido ampliamente adoptado por personas que descubrieron que hacía mucho más fácil producir aplicaciones y servicios distribuidos. El tipo de medio de Internet oficial 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 clasificar, 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 la 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 derivó 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 del mundo. Es mejor conocido como el lenguaje incorporado 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, siendo la más conocida 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 convirtió en global, la "marca registrada" "Ecma" se mantuvo por razones históricas.

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

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

• Lenguaje SQL - Hibernate MySQL Dialect, Oracle Dialect, ... que tiene algunos cambios o funcionalidad adicional.

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. language resources JavaScript .

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 4ª 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 usas otro que no sea String, se convertirá en String. Pero no se recomienda usar claves distintas a las de String. Verifique un ejemplo como este: { ''key'':''val'' } sobre 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. ► Las cadenas JSON deben indicarse 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 literalmente proporcionas en tu script.
   • 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 los caracteres especiales. Pero no se recomienda escapar ('') Comillas simples. En el modo Estricto se lanzará y Error - SyntaxError: Unexpected token '' in JSON - Error SyntaxError: Unexpected token '' in JSON

   Verifique con este código { "Hai/" /n Team 🔫":5, "Bye /'": 7 } través de JSON Edtions en línea. 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"}

Los accesores de propiedades de objetos proporcionan acceso a las propiedades de un objeto utilizando 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 ser 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"}

► JavaScript es 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 corchetes que rodean cero o más pares de nombre / valor (o miembros). Un nombre es una cadena. Una sola coma viene después de cada nombre, separando el nombre del valor. Una sola coma separa un valor de un nombre siguiente. Los nombres dentro de un objeto DEBEN ser únicos.

ECMAScript soporta 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 se lleva a cabo mediante instancias, los métodos se llevan a cabo mediante clases y la herencia es solo de estructura y comportamiento. En ECMAScript, el estado y los métodos se transmiten por objetos, y la estructura, el comportamiento y el estado se heredan.

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ícitamente al prototipo asociado del constructor con el fin de resolver las referencias de propiedad. El prototipo asociado al constructor puede ser referenciado por la expresión de programa constructor.prototype, y las propiedades agregadas al prototipo de un objeto son compartidas, por herencia, por todos los objetos que comparten el prototipo.

Answer 8

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

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