¿Cuál es la diferencia entre JSON y la notación literal de objetos?

StackOverflow https://stackoverflow.com/questions/2904131

Pregunta

Puede alguien decirme cuál es la principal diferencia entre un objeto de JavaScript definida por el uso de objeto literal notación y objeto JSON

De acuerdo con un libro de JavaScript que dice que esto es un objeto definido por el uso de Objeto de la notación 

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

Por qué no es un objeto JSON en este caso? El hecho de que no se define por el uso de las comillas?

¿Fue útil?

Solución

Le permite aclarar primero qué JSON en realidad es. JSON es un Pruebas , el formato de intercambio de datos de lenguaje-parte independiente, al igual que XML, CSV o YAML.

Los datos se pueden almacenar en muchos aspectos, pero si se debe almacenar en un archivo de texto y sea legible por un ordenador, que tiene que seguir algún tipo de estructura. JSON es uno de los muchos formatos que definen tal estructura a.

Estos formatos son típicamente independiente 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 manera de definir / describir los datos, pero la sintaxis es muy específica para JavaScript.

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

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

JSON tiene las siguientes limitaciones sintácticas:

  • Objeto teclas debe ser cadenas (es decir, una secuencia de caracteres entre comillas dobles ").
  • Los valores pueden ser:
    • una cadena
    • varios
    • una (JSON) objeto
    • una matriz
    • true
    • false
    • null
  • llaves duplicadas ({"foo":"bar","foo":"baz"}) productos indefinido, los resultados específicos de la implementación; la especificación JSON específicamente no define su semántica

En JavaScript, objetos literales puede tener

  • literales de cadena, los literales de número o identificador nombres como llaves (desde ES6, llaves ahora también puede ser computado, que introduce otra sintaxis).
  • Los valores puede ser cualquier expresión JavaScript válido, incluyendo las definiciones de función y undefined.
  • llaves duplicadas producir definido, los resultados especificados (en modo suelto, la última definición sustituye a la anterior; en modo estricto, es un error).

Sabiendo que, simplemente se busca en el sintaxis , el ejemplo no es JSON debido a dos razones:

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

Pero lo más importante, para repetir mi explicación desde el principio: Usted está en un contexto JavaScript. Se define un objeto de JavaScript. En su caso, un "objeto JSON" sólo puede estar contenida 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ás escribiendo código JavaScript de origen, y no se trata de un cadena , no eres tratar con JSON. Tal vez que recibió los datos como JSON (por ejemplo, a través de AJAX o la lectura de un archivo), pero una vez que usted o una biblioteca que está utilizando ha analizado que, no es JSON más.

.

Sólo porque literales de objetos y apariencia JSON similares , que no quiere decir que usted puede nombrar indistintamente Ver también no hay tal cosa como un "objeto JSON" .

Otros consejos

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

  • Los valores clave debe ser citado
  • Las cadenas deben ser citado con " y no '
  • Usted tiene un rango más limitado de valores (por ejemplo, no hay funciones permitido)

En realidad no hay tal cosa como un "objeto JSON".

La especificación JSON es una sintaxis para codificar datos como una cadena. Lo que se llama un "objeto JSON" (en javascript) es en realidad un objeto Javascript ordinaria que tiene (probablemente) sido deserializado de una cadena JSON válida, y puede ser fácilmente re-serializado como una cadena JSON válida. Esto generalmente significa que sólo contiene datos (y no funciones). También significa que no hay fechas, debido a JSON no tiene un tipo de fecha (probablemente la cosa más dolorosa sobre JSON;)

Además, (de lado diatriba ...) cuando se habla de un "objeto JSON", casi siempre datos medios que tiene el "entre llaves" en el nivel superior. Esto corresponde bien a un objeto de javascript. Sin embargo, la especificación JSON no requiere que exista una única "entre llaves" objeto en el nivel superior de una cadena JSON. Es perfectamente válido JSON para tener una lista en el primer nivel, o incluso tener sólo un único valor. Así, mientras que cada corresponde "JSON del objeto" a JSON válida, no todas las cadenas JSON válidos corresponden a lo que podríamos llamar un "objeto JSON"! (Ya que la cadena podría representar una lista o un valor atómico)

Según JSON en JavaScript ,

JSON es un subconjunto del objeto notación literal de JavaScript.

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

Además de la lectura de la documentación , como se sugiere @Filix Rey, yo también sugieren jugar un poco con el < a href = "http://www.jsonlint.com/" rel = "noreferrer"> JSONLint línea JSON validador . Así es como he aprendido que las claves de objetos JSON deben ser cadenas.

?? JSON : la alternativa libre de grasa a XML

JSON ha sido ampliamente adoptado por la gente que se ha encontrado que hace que sea mucho más fácil de producir aplicaciones y servicios distribuidos. El tipo de medio de Internet oficial de JSON es application/json RFC 4627 . nombres de archivo JSON utilizan el .json extensión.

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

El objeto JSON es un objeto único que contiene dos funciones, de análisis sintáctico y stringify, que se utilizan para textos JSON de análisis sintáctico y construir.

  • 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 será incluido 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 subconjunto de JavaScript. Javascript se derivó del ECMAScript Lenguaje de programación estándar.

? ECMAScript

ECMAScript ha crecido hasta convertirse en uno de los lenguajes de programación de propósito general más utilizados en el mundo. Es el más conocido como el idioma integrado en los navegadores web, pero también ha sido ampliamente adoptado para servidores y aplicaciones embebidas. ECMAScript se basa en varias tecnologías originarios, el más conocido es JavaScript (Netscape comunicaciones)) y JScript (Microsoft Corporation).) . Si bien antes de 1994, ECMA era conocido como "Asociación Europea de Fabricantes de Equipo", después de 1994, cuando se convirtió en la organización mundial, la "marca" "ECMA" se mantuvo por razones históricas.

ECMAScript es la lengua, mientras que JavaScript, JScript, e incluso ActionScript se llama "Dialects" .

Los dialectos se han derivado de la misma lengua. Son son bastante similares entre sí, ya que se han derivado de la misma lengua, sino que han experimentado algunos cambios. Un dialecto es una variación en el lenguaje mismo. Se deriva de un solo idioma.

  • Lenguaje SQL -. Hibernate MySQL dialecto, Oracle dialecto, .. que tienen algunos cambios o funcionalidad añadida

Información sobre el navegador y el ordenador de los usuarios. 

navigator.appName // "Netscape"

ECMAScript es el lenguaje de scripting 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 « 4ª edición de ECMAScript no publicó como obra estaba incompleta .

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

  1. ? Los valores clave deben ser citados, sólo cadenas permitido para las llaves. Si utiliza distintos de cuerdas que se convertirá en cadena. Pero no se recomienda utilizar las teclas que no sean de cuerda de. Comprobar un ejemplo como éste - { '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. ? JSON Cuerdas debe ser citado con "y no'. Una cadena es muy parecido a una cadena C o Java. Cuerdas debe ser envuelto entre comillas dobles.

    • Los literales valores son fijos, no variables, que proporcionan literalmente en el script.
    • Una cadena es una secuencia de cero o más caracteres entre comillas envueltos con escape de barra invertida, la misma notación que se utiliza en la mayoría de los lenguajes de programación.
      • ??. - Símbolos especiales están permitidos en cadena, pero no recomienda utilizar
      • \" - Los caracteres especiales se puede escapar, pero no recomendado para escapar ( ') entre comillas simples.. En modo estricto que va a tirar y Error - SyntaxError: Unexpected token ' in JSON

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

Propiedad descriptores de acceso proporcionar acceso a propiedades de un objeto mediante el uso de la anotación de puntos o la notación soporte.

  1. ? Usted tiene un rango más limitado de valores (por ejemplo, no hay funciones permitido). Un valor puede ser una cadena en comillas dobles, número, boolean, null, objeto o matriz. Estas estructuras se pueden anidar. 

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

introducir descripción de la imagen aquí

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

JavaScript es un lenguaje de tipos dinámicos. Eso significa que usted no tiene que especificar el tipo de datos de una variable cuando se 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

estructura de un objeto es representado como un par de llaves que rodean cero o más pares nombre / valor (o miembros). Un nombre es una cuerda. Una sola de colon viene después de cada nombre, separando el nombre del valor. Una sola coma separa un valor de una siguiente nombre. Los nombres dentro de un objeto debe ser único.

ECMAScript admite la herencia basado en prototipos. Cada constructor tiene un prototipo asociada, y cada objeto creado por el constructor que tiene una referencia implícita al prototipo (llamado de los objetos prototipo) asociada a su constructor. Además, un prototipo puede tener una referencia implícita no nulo a su prototipo, y así sucesivamente; esto se llama la cadena de prototipo.

En un lenguaje orientado a objetos basado en clases, en general, el estado es portado por instancias, los métodos son portados por clases, y la herencia es únicamente de estructura y comportamiento. En ECMAScript, el estado y los métodos son portados por objetos, y la estructura, el comportamiento y el estado son todos heredan.

Un prototipo es un objeto utilizado para implementar la estructura, el estado y el comportamiento de herencia en ECMAScript. Cuando un constructor crea un objeto, ese objeto hace referencia implícita asociada prototipo del constructor con el propósito de resolver las referencias de propiedad. asociada prototipo de lata de constructores ser referenciados por la expresión constructor.prototype programa y propiedades añadidas al prototipo de un objeto se comparten, por herencia, por todos los objetos que comparten el prototipo.

Para los que todavía piensan que el RFC son más importantes que los blogs y conceptos erróneos basados ??opinión, vamos a tratar de responder a aclarar algunos puntos. No voy a repetir todas las diferencias correctas ya mencionados en las respuestas anteriores, aquí sólo estoy tratando de valor añadido que resume una parte fundamental rfc7159

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

  1. JavaScript Objeto Notación (JSON) es un formato de texto para el serialización de datos estructurados. Se deriva de la objeto Los literales de JavaScript, como se define en la programación ECMAScript Lengua estándar, Tercera Edición [ECMA-262].
  2. JSON puede representar cuatro tipos primitivos (cadenas, números, booleanos, y null) y dos tipos estructurados ( objetos y arrays).
  3. Un objeto es una colección desordenada de cero o más nombre / valor pares, donde un nombre es una cadena y un valor es una cadena, número, boolean, null, objeto , o array.
  4. comenzar a objetos = ws% X7b ws; {Corchete izquierdo
  5. extremo a objetos = ws% X7d ws; } Corchete derecho
  6. valor A JSON DEBE ser un objeto , matriz, número o cadena, o una de los siguientes tres nombres literales: nula falsa verdadera
  7. Un objeto estructura se representa como un par de llaves
  8. Los nombres dentro de un objeto debe ser único. objeto = comenzar a objetos [miembro * (miembro de valor-separador)] extremo a objetos
  9. Un objetivo cuyos nombres son todos únicos es interoperable en el sentido que todas las implementaciones de software de recepción que objetivo acordarán las asignaciones de nombre-valor. Cuando los nombres dentro de un objetivo no son único, el comportamiento del software que recibe como un objetivo 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 imagen es miembro de un objetivo en miniatura cuyo miembro es un objetivo y cuyo miembro IDs es una matriz de números.

En realidad no hay tal cosa como un "objeto JSON".

¿En serio?

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

JSON es una especie de envoltura sobre "JavaScript Object Notation", que obliga a los usuarios a obedecer normas más estrictas para la definición de los objetos. Y lo hace mediante la limitación de las posibles formas de declaración de objeto proporcionados por función JavaScript Object Notation.

Como resultado tenemos unos objetos más simples y estandarizados que se adapte mejor en los datos de intercambio entre plataformas.

Así que, básicamente, la newObject en mi ejemplo anterior es un objeto definido por el uso de JavaScript Objeect notación; pero no es un objeto JSON 'válidos', ya que no sigue las reglas que requieren las normas JSON.

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

En primer lugar, debe saber lo que es JSON:

Es formato de intercambio de datos independiente del idioma. La sintaxis de JSON se inspiró en el JavaScript notación literal de objetos, pero hay diferencias entre ellos.

Por ejemplo, en JSON todas las claves debe ser citado, mientras que en los literales de objetos esto no es necesario:

// JSON: { "Foo": "barra"}

// literal del objeto: var o = {ejem: "barra"}; Las citas son obligatorios en JSON porque en JavaScript (. Más exactamente en ECMAScript 3ª edición), no está permitido el uso de palabras reservadas como nombres de propiedades, por ejemplo:

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

o = {var "si": "foo"}; Así que para la "compatibilidad" (y fácil eval'ing tal vez?) Las cotizaciones son obligatorios.

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

string número objeto formación Un literal como: cierto falso nulo La gramática de Cuerdas cambia. Tienen que estar delimitado por comillas dobles, mientras que en JavaScript, puede utilizar comillas simples o dobles de manera intercambiable.

// no válida JSON: { "Foo": 'bar'} La gramática JSON aceptada de Números también cambia, en JavaScript puede utilizar hexadecimales literales, por ejemplo 0xFF, o (los infames) Los literales octales por ejemplo, 010. En JSON sólo puede usar decimales literales.

// no válida JSON: { "Foo": 0xFF}

Javascript objeto literal vs JSON:

  • Objeto de sintaxis literal es una forma muy conveniente para crear objetos de JavaScript
  • El lenguaje JSON, acrónimo de 'notación de objetos JavaScript', tiene su sintaxis derivada de sintaxis literal de objeto JavaScript. Se utiliza como un formato de transferencia de datos textual, lenguaje de programación.

Ejemplo:

JS objeto notación, utilizado 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;"
    }
}}

diferencias principales:

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

  • Todas las cadenas en JSON debe ser citado en "comillas dobles". Mientras que en Javascript se permiten dos comillas simples y comillas dobles. Incluso sin comillas en el objeto Javascript notación de las claves de objeto están fundidas implícitamente a las cadenas.

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

Javascript acumulación en el objeto JSON:

Los objetos JSON se pueden convertir fácilmente a Javascript y viceversa utilizando el construido en objeto JSON cuales Javascript ofertas 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

Esta es una diferencia sorprendente: no se puede utilizar undefined en JSON y todos los campos de objeto con valores no definidos desaparecerá despué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) );

??????

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top