Alguém pode me dizer qual é a principal diferença entre um objeto JavaScript definido usando o Object Literal Notation e o objeto JSON ?

De acordo com um livro JavaScript, ele diz que este é um objeto definido usando a Notação de Objeto :

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

Por que não é um objeto JSON neste caso? Só porque não é definido usando aspas?

Vamos esclarecer primeiro o que realmente é o JSON . JSON é um formato textual de troca de dados, independente de idioma, como XML, CSV ou YAML.

Os dados podem ser armazenados de várias maneiras, mas se devem ser armazenados em um arquivo de texto e legíveis por um computador, é necessário seguir alguma estrutura. JSON é um dos muitos formatos que definem essa estrutura.

Esses formatos geralmente são independentes da linguagem, o que significa que podem ser processados ​​por Java, Python, JavaScript, PHP, etc.

Por outro lado, o JavaScript é uma linguagem de programação. É claro que o JavaScript também fornece uma maneira de definir / descrever dados, mas a sintaxe é muito específica para o JavaScript.

Como um exemplo contrário, o Python tem o conceito de tuplas , sua sintaxe é (x, y). JavaScript não tem algo parecido com isto.

Vamos examinar as diferenças sintáticas entre literais de objetos JSON e JavaScript.

JSON tem as seguintes restrições sintáticas:

• As chaves de objeto devem ser cadeias de caracteres (isto é, uma sequência de caracteres entre aspas duplas ").
• Os valores podem ser:
  • uma linha
  • um número
  • um objeto (JSON)
  • uma matriz
  • true
  • false
  • null
• Chaves duplicadas ( {"foo":"bar","foo":"baz"}) produzem resultados indefinidos e específicos da implementação; a especificação JSON especificamente não define sua semântica

Em JavaScript, literais de objetos podem ter

• Literais de seqüência de caracteres, literais de número ou nomes de identificadores como chaves (desde ES6, as chaves agora também podem ser calculadas, o que introduz outra sintaxe).
• Os valores podem ser qualquer expressão JavaScript válida, incluindo definições de função e undefined.
• Teclas duplicadas produzem resultados definidos e especificados (no modo flexível, a última definição substitui a anterior; no modo estrito, é um erro).

Sabendo que, apenas olhando a sintaxe , seu exemplo não é JSON por dois motivos:

1. Suas chaves não são cadeias de caracteres (literais). Eles são nomes de identificador .
2. Você não pode atribuir uma função como valor a um "objeto JSON" (porque o JSON não define nenhuma sintaxe para funções).

Mas o mais importante, para repetir minha explicação desde o início: você está em um contexto JavaScript. Você define um objeto JavaScript. Se houver, um "objeto JSON" só pode estar contido em uma sequência:

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

Ou seja, se você estiver escrevendo o código-fonte JavaScript e não lidando com uma sequência , não está lidando com o JSON. Talvez você tenha recebido os dados como JSON (por exemplo, via ajax ou lendo um arquivo), mas depois que você ou uma biblioteca que você está usando o analisou, ele não é mais JSON.

Somente como literais de objeto e JSON parecem semelhantes , isso não significa que você pode nomeá-los de forma intercambiável. Consulte também Não existe um "objeto JSON" .

JSON tem uma sintaxe muito mais limitada, incluindo:

• Os valores-chave devem ser citados
• As strings devem ser citadas com "e não'
• Você tem uma faixa de valores mais limitada (por exemplo, nenhuma função é permitida)

Realmente não existe um "objeto JSON".

A especificação JSON é uma sintaxe para codificar dados como uma sequência. O que as pessoas chamam de "Objeto JSON" (em javascript) é realmente apenas um objeto javascript comum que (provavelmente) foi desserializado de uma sequência JSON válida e pode ser facilmente re-serializado como uma sequência JSON válida. Isso geralmente significa que ele contém apenas dados (e não funções). Isso também significa que não há datas, porque o JSON não possui um tipo de data (provavelmente a coisa mais dolorosa sobre o JSON;)

Além disso, quando as pessoas falam sobre um "Objeto JSON", elas quase sempre significam dados que possuem "chaves" no nível superior. Isso corresponde muito bem a um objeto javascript. No entanto, a especificação JSON não exige que haja um único objeto "chaves" no nível superior de uma sequência JSON. É perfeitamente válido o JSON ter uma lista no nível superior ou até ter apenas um único valor. Portanto, enquanto todo "Objeto JSON" corresponde a JSON válido, nem todas as sequências JSON válidas correspondem ao que chamaríamos de "Objeto JSON"! (porque a sequência pode representar uma lista ou um valor atômico)

De acordo com o JSON em JavaScript ,

JSON é um subconjunto da notação literal de objeto de JavaScript.

Em outras palavras, JSON válido também é uma notação literal de objeto JavaScript válida, mas não necessariamente o contrário.

Além de ler a documentação , como o @Filix King sugeriu, também sugiro brincar com o validador JSON on-line JSONLint . Foi assim que aprendi que as chaves dos objetos JSON devem ser cadeias de caracteres.

🔫 JSON : a alternativa sem gordura ao XML

O JSON foi amplamente adotado por pessoas que descobriram que tornava muito mais fácil produzir aplicativos e serviços distribuídos. O tipo de mídia oficial da Internet para JSON é application/json RFC 4627. Nomes de arquivos JSON usar a extensão .json.

► JavaScript Object Notation ( JSON) é um formato de intercâmbio de dados leve, baseado em texto e independente de idioma. JSON foi usado para trocar dados entre aplicativos escritos em qualquer linguagem de programação.

O objeto JSON é um único objeto que contém duas funções, analisar e stringify, usadas para analisar e construir textos JSON.

• JSON.stringify produz uma String em conformidade com a seguinte gramática JSON.
• JSON.parse aceita uma String em conformidade com a gramática JSON.

O método parseJSON será incluído no Fourth Edition of ECMAScript. Enquanto isso, uma implementação JavaScript está disponível em 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 é um subconjunto de JavaScript. O Javascript foi derivado do ECMAScript Programming Language Standard.

► ECMAScript

O ECMAScript cresceu e se tornou uma das linguagens de programação de uso geral mais usadas no mundo. É mais conhecido como o idioma incorporado nos navegadores da Web, mas também foi amplamente adotado para servidores e aplicativos incorporados. O ECMAScript é baseado em várias tecnologias originárias, sendo as mais conhecidas JavaScript(Netscape Communications) e JScript(Microsoft Corporation).) . Embora antes de 1994, a ECMA fosse conhecida como "Associação Europeia de Fabricantes de Computadores", depois de 1994, quando a organização se tornou global, a "marca" "Ecma" foi mantida por razões históricas.

ECMAScript é a linguagem, enquanto JavaScript, JScript e até ActionScript são chamados "Dialects".

Os dialetos foram derivados do mesmo idioma. Eles são bastante parecidos entre si, pois foram derivados do mesmo idioma, mas sofreram algumas alterações. Um dialeto é uma variação no próprio idioma. É derivado de um único idioma.

• Linguagem SQL - Hibernate MySQL Dialect, Oracle Dialect, .. que apresentam algumas alterações ou funcionalidades adicionais.

Informações sobre o navegador e o computador de seus usuários.

navigator.appName // "Netscape"

ECMAScript é a linguagem de script que forma a base do 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ª edição do ECMAScript não publicada porque o trabalho estava incompleto .

JSON define um pequeno conjunto de regras de formatação para a representação portátil de dados estruturados.

1. ► Os valores das chaves devem ser citados, apenas Strings são permitidas para chaves. Se você usar outro que não seja String, ele será convertido em String. Mas não é recomendável usar outras chaves além das de String. Veja um exemplo como este - { 'key':'val' }acimaRFC 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. ► As strings JSON devem ser citadas com "e não". Uma string é muito parecida com uma string C ou Java. As strings devem ser colocadas entre aspas duplas.

   • Literais são valores fixos, não variáveis, que você literalmente fornece em seu script.
   • Uma string é uma sequência de zero ou mais caracteres entre aspas com escape de barra invertida, a mesma notação usada na maioria das linguagens de programação.
     • Symbols - Símbolos especiais são permitidos em String, mas não são recomendados.
     • \ "- Caracteres especiais podem ser escapados. Mas não é recomendado escapar (') aspas simples. No modo Estrito, ele lançará e Error - SyntaxError: Unexpected token ' in JSON

   Verifique com este código as { "Hai\" \n Team 🔫":5, "Bye \'": 7 }edições JSON online.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"}

Os acessadores de propriedade de objeto fornecem acesso às propriedades de um objeto usando a notação de ponto ou de colchete.

3. ► Você tem uma faixa de valores mais limitada (por exemplo, nenhuma função é permitida). Um valor pode ser uma cadeia de caracteres entre aspas duplas, número, booleano, nulo, objeto ou matriz. Essas estruturas podem ser aninhadas.

   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é a implementação mais popular do padrão ECMAScript. Os principais recursos do Javascript são baseados no padrão ECMAScript, mas o Javascript também possui outros recursos adicionais que não estão nas especificações / padrão do ECMA. Todo navegador tem um intérprete de JavaScript.

JavaScript é uma linguagem de tipo dinâmico. Isso significa que você não precisa especificar o tipo de dados de uma variável quando a declara, e os tipos de dados são convertidos automaticamente conforme necessário durante a execução do 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

Uma estrutura de objeto é representada como um par de colchetes envolvendo zero ou mais pares de nome / valor (ou membros). Um nome é uma string. Um único dois pontos vem após cada nome, separando o nome do valor. Uma única vírgula separa um valor do seguinte nome. Os nomes dentro de um objeto devem ser únicos.

O ECMAScript suporta herança baseada em protótipo. Todo construtor tem um protótipo associado e todo objeto criado por esse construtor tem uma referência implícita ao protótipo (chamado protótipo do objeto) associado ao seu construtor. Além disso, um protótipo pode ter uma referência implícita não nula ao seu protótipo, e assim por diante; isso é chamado de cadeia de protótipo.

Em uma linguagem orientada a objetos baseada em classe, em geral, o estado é carregado por instâncias, os métodos são carregados por classes e a herança é apenas de estrutura e comportamento. No ECMAScript, o estado e os métodos são transportados por objetos, e a estrutura, o comportamento e o estado são todos herdados.

Um protótipo é um objeto usado para implementar a herança de estrutura, estado e comportamento no ECMAScript. Quando um construtor cria um objeto, esse objeto faz referência implícita ao protótipo associado ao construtor com o objetivo de resolver as referências de propriedade. O protótipo associado ao construtor pode ser referenciado pela expressão do programa constructor.prototype, e as propriedades adicionadas ao protótipo de um objeto são compartilhadas, por herança, por todos os objetos que compartilham o protótipo.

Para aqueles que ainda pensam que a RFC é mais importante do que blogs e equívocos baseados em opiniões, vamos tentar esclarecer alguns pontos. Não vou repetir todas as diferenças corretas já mencionadas nas respostas anteriores, aqui só estou tentando agregar valor resumindo uma parte crucial rfc7159

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

1. JSON ( JavaScript Object Notation) é um formato de texto para a serialização de dados estruturados. É derivado dos objetos literais de JavaScript, conforme definido no ECMAScript Programming Language Standard, Terceira Edição [ECMA-262].
2. JSON pode representar quatro tipos primitivos (cadeias, números, booleanos e nulos) e dois tipos estruturados ( objetos e matrizes).
3. Um objeto é uma coleção não ordenada de zero ou mais pares de nome / valor, em que um nome é uma sequência e um valor é uma sequência, número, booleano, nulo, objeto ou matriz.
4. objeto inicial =% ws x7B ws; {colchete esquerdo
5. objeto final = ws% x7D ws; } colchete direito
6. Um valor JSON DEVE ser um objeto , matriz, número ou string ou um dos três nomes literais a seguir: false null true
7. Uma estrutura de objeto é representada como um par de colchetes
8. Os nomes dentro de um objeto devem ser únicos. objeto = objeto inicial [membro * (membro separador de valor)] objeto final
9. Um objeto cujos nomes são todos únicos é interoperável no sentido de que todas as implementações de software que recebem esse objeto concordam com os mapeamentos de valor de nome. Quando os nomes dentro de um objeto não são exclusivos, o comportamento do software que recebe esse objeto é imprevisível.

10. Exemplos (da página 12 da RFC)

    Este é um 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]
              }
          }

    Seu membro Image é um objeto cujo membro Thumbnail é um objeto e cujo membro IDs é uma matriz de números.

Realmente não existe um "objeto JSON".

Realmente?

Tanto quanto eu entendo, a principal diferença é a flexibilidade .

JSON é um tipo de invólucro na "JavaScript Object Notation" que força os usuários a obedecer regras mais estritas para definir os objetos. E isso é feito limitando as possíveis formas de declaração de objetos fornecidas pelo recurso JavaScript Object Notation.

Como resultado, temos objetos mais simples e padronizados que melhor se adaptam à troca de dados entre plataformas.

Então, basicamente, o newObject no meu exemplo acima é um objeto definido pelo JavaScript Objeect Notation; mas não é um objeto JSON 'válido' porque não segue as regras exigidas pelos padrões JSON.

Este link também é bastante útil: http://msdn.microsoft.com/en-us/library/bb299886.aspx

Primeiro você deve saber o que é JSON:

É um formato de intercâmbio de dados independente de idioma. A sintaxe do JSON foi inspirada na notação literal de objeto JavaScript, mas há diferenças entre eles.

Por exemplo, em JSON todas as chaves devem ser citadas, enquanto em literais de objeto isso não é necessário:

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

// literal do objeto: var o = {foo: "bar"}; As aspas são obrigatórias no JSON, porque no JavaScript (mais exatamente no ECMAScript 3rd. Edition), o uso de palavras reservadas como nomes de propriedades é proibido, por exemplo:

var o = {if: "foo"}; // SyntaxError no ES3 Enquanto, o uso de uma literal de cadeia de caracteres como um nome de propriedade (citando o nome da propriedade) não apresenta problemas:

var o = {"se": "foo"}; Portanto, para "compatibilidade" (e fácil avaliação, talvez?), As cotações são obrigatórias.

Os tipos de dados em JSON também são restritos aos seguintes valores:

string number objeto array Um literal como: true false null A gramática de Strings muda. Eles devem ser delimitados por aspas duplas, enquanto em JavaScript, você pode usar aspas simples ou duplas de forma intercambiável.

// JSON inválido: {"foo": 'bar'} A gramática JSON aceita de Numbers também muda, no JavaScript você pode usar literais hexadecimais, por exemplo 0xFF, ou (os infames) literais octais (por exemplo, 010). No JSON, você pode usar apenas literais decimais.

// JSON inválido: {"foo": 0xFF}

Objeto Javascript Literal vs JSON:

• A sintaxe literal de objeto é uma maneira muito conveniente de criar objetos javascript
• A JSONlinguagem, que significa 'notação de objeto Javascript', tem sua sintaxe derivada da sintaxe literal do objeto javascript. É usado como um formato de transferência de dados textuais independente da linguagem de programação.

Exemplo:

Notação de objeto JS, usada em JS para criar objetos no 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
}

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

Principais diferenças:

• Todas as chaves de objeto no JSON devem ser cadeias. No Javascript, as chaves do objeto podem ser cadeias ou números

• Todas as strings no JSON devem ser citadas entre "aspas duplas". Enquanto em Javascript são permitidas aspas simples e duplas. Mesmo sem aspas na notação de objeto Javascript, as chaves do objeto são convertidas implicitamente em cadeias.

• No JSON, uma função não pode ser definida como um valor de um objeto (já que isso é específico do Javascript). Em Javascript, isso é completamente legal.

Construção de Javascript no JSONobjeto:

JSONos objetos podem ser facilmente convertidos em Javascript e vice-versa usando o JSONobjeto incorporado que o Javascript oferece em seu tempo de execução. Por exemplo:

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

Aqui está uma diferença surpreendente: você não pode usar undefinedno json e todos os campos de objetos com valores indefinidos desaparecerão apó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) );

🙈🙉🙊