JSON 和对象文字表示法有什么区别？

https://stackoverflow.com/questions/2904131

04-10-2019
|

题

有人可以告诉我使用定义的 JavaScript 对象之间的主要区别是什么 对象文字表示法 和 JSON 对象?

根据一本 JavaScript 书，它说这是一个通过使用定义的对象 对象表示法:

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

为什么在这种情况下它不是一个 JSON 对象？仅仅因为它不是用引号定义的？

解决方案

让我们首先澄清什么 JSON 实际上是。 Json是一个文字, ，语言 - 语言数据交换格式，非常类似于XML，CSV或YAML。

数据可以以多种方式存储，但是如果应该将其存储在文本文件中并通过计算机可读，则需要遵循一些结构。 JSON是定义这种结构的众多格式之一。

这样的格式通常是独立于语言的，这意味着可以通过Java，Python，JavaScript，PHP来处理它们。

相比之下， JavaScript 是一种编程语言。当然，JavaScript还提供了一种定义/描述数据的方法，但是该语法非常特定于JavaScript。

作为反面的例子，Python有一个概念元组, ，他们的语法是 (x, y). 。 JavaScript没有这样的东西。

让我们看一下JSON和JavaScript对象文字之间的句法差异。

JSON具有以下句法约束：

目的钥匙一定是 字符串 （即包含双引号的字符序列 ").
值可以是：
- 字符串
- 一个号码
- 一个（JSON）对象
- 数组
- true
- false
- null
重复键（{"foo":"bar","foo":"baz"}）产生不确定的实施特定结果； JSON规范没有明确定义其语义

在JavaScript中，对象文字可以具有

字符串文字，数字文字或标识符名称为键（由于ES6，现在也可以计算键，这引入了另一种语法）。
值可以是任何有效的JavaScript表达式，包括功能定义和 undefined.
重复的键产生定义的指定结果（在松散模式下，后一个定义取代了前者；在严格的模式下，这是一个错误）。

知道这一点，只是看着句法, ，您的示例不是JSON，因为有两个原因：

您的钥匙不是字符串（文字）。他们是 标识符名称.
您不能将函数分配为“ JSON对象”的值（因为JSON并未为函数定义任何语法）。

但最重要的是，从一开始重复我的解释：您处于JavaScript上下文中。您定义一个JavaScript对象。如果有的话，“ JSON对象”只能包含在字符串中：

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

也就是说，如果您正在编写JavaScript源代码，并且不处理细绳, ，您没有与JSON打交道。也许您将数据收到JSON（例如，通过Ajax或从文件中读取），但是一旦您使用的库已解析，它就不再是JSON了。

只是因为对象文字和json外观 相似的, ，这并不意味着您可以互换名称。 也可以看看没有“ json对象”这样的东西.

其他提示

JSON 具有更有限的语法，包括：

必须引用关键值
字符串必须引用 " 并不是 '
您的值范围更有限（例如不允许函数）

确实没有“ JSON对象”之类的东西。

JSON规格是用于将数据编码为字符串的语法。人们所说的“ JSON对象”（在JavaScript中）实际上只是一个普通的JavaScript对象，该对象（可能）已被从有效的JSON字符串中去除，并且可以轻松地重新序列化为有效的JSON字符串。这通常意味着它仅包含数据（而不是功能）。这也意味着没有日期，因为JSON没有日期类型（可能是JSON最痛苦的事情；）

此外，当人们谈论“ JSON对象”时（侧滚动...），它们几乎总是表示具有顶级“卷发式”的数据。这很好地对应于JavaScript对象。但是，JSON规格不需要JSON字符串的顶级上有一个“卷曲式”对象。在顶级列表甚至只有一个值的列表是完全有效的JSON。因此，尽管每个“ JSON对象”都对应于有效的JSON，但并非所有有效的JSON字符串都与我们所说的“ JSON对象”相对应！（因为字符串可以代表列表或原子值）

根据 JSON在JavaScript中,

Json是一个子集 javaScript的对象字面符号。

换句话说，有效的JSON也是有效的JavaScript对象文字符号，但不一定是相反。

除了阅读文档, ，正如@filix King所建议的那样，我也建议您与 JSONLINT在线JSON验证器. 。这就是我了解JSON对象的钥匙必须是字符串的方式。

🔫 JSON: ：XML的无脂肪替代品

JSON已被人们广泛采用，他们发现这使得生产分布式应用程序和服务变得容易得多。 JSON的官方互联网媒体类型是 application/json RFC 4627. 。 JSON文件名使用扩展名 .json.

►JavaScript对象表示法（JSON）是一种轻巧的，基于文本的，独立于语言的数据互换格式。 JSON已用于在任何编程语言编写的应用程序之间交换数据。

JSON对象是一个单个对象，包含两个函数，分析和弦乐，用于解析和构造JSON文本。

JSON.STRINGIFY产生的字符串符合以下JSON语法。

JSON.PARSE接受一根符合JSON语法的弦。

parsejson方法将包括在 Fourth Edition of ECMAScript. 。同时，可以在json.org上获得JavaScript实现。

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是JavaScript的子集。 JavaScript 源自Ecmascript编程语言标准。

►eCMAScript

Ecmascript已成长为世界上最广泛的通用编程语言之一。它最著名的是嵌入Web浏览器中的语言，但也已被广泛用于服务器和嵌入式应用程序。 eCmascript基于几种原始技术，最著名的是 JavaScript （Netscape Communications））和 JScript （微软公司）。）. 尽管在1994年之前，ECMA被称为“欧洲计算机制造商协会”，但1994年后，该组织成为全球，但出于历史原因而保留了“商标”“ ECMA”。

eCmascript是语言 "Dialects".

方言是从同一语言得出的。它们彼此非常相似，因为它们是从相同的语言中得出的，但是他们经历了一些变化。方言是语言本身的变化。它源自单一语言。

SQL语言 - Hibernate MySQL方言，Oracle方言，具有一些更改或添加功能。

有关用户浏览器和计算机的信息。

navigator.appName // "Netscape"

Ecmascript是构成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.

笔记 ” 第四版 ecmascript没有由于工作不完整而出版.

JSON为结构化数据的便携式表示定义了一小部分格式规则。

►必须引用钥匙值，仅允许键的字符串。如果您使用其他字符串，它将转换为字符串。但不建议使用字符串以外的键。检查这样的示例 - { 'key':'val' } 超过 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() {}' ] );

►必须用“而不是”引用JSON字符串。字符串非常像C或Java字符串。 字符串应用双引号包裹。
- 文字是您在脚本中实际提供的固定值，而不是变量。
- 字符串是用引号包裹的零或更多字符的序列，带有后斜切逃脱，与大多数编程语言中使用的符号相同。
  - 🔫-字符串中允许使用特殊符号，但不建议使用。
  - “ - 可以逃脱特殊字符。但不能推荐以逃脱（'）单引号。在严格的模式下，它会抛出和错误 - SyntaxError: Unexpected token ' in JSON
使用此代码检查 { "Hai\" \n Team 🔫":5, "Bye \'": 7 } 超过在线JSON EDTIONS。 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"}
```

目的物业访问者使用点表示法或括号符号提供对对象属性的访问。

►您的值范围更有限（例如不允许函数）。值可以是双引号，数字，布尔值，空，对象或数组中的字符串。这些结构可以嵌套。

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 是Ecmascript标准的最受欢迎的实现。 JavaScript的核心功能基于Ecmascript标准，但是JavaScript还具有其他不在ECMA规范/标准中的其他功能。 每个浏览器都有一个JavaScript解释器。

JavaScript是一种动态键入的语言。这意味着您不必在声明变量时指定数据类型，并且在执行脚本执行过程中会根据需要自动转换数据类型。

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

对象结构表示为围绕零或更多名称/值对（或成员）的一对卷曲支架。名称是字符串。每个名称都出现一个结肠，将名称与值分开。单个逗号将值与以下名称分开。对象中的名称应该是唯一的。

eCmascript支持基于原型的继承。每个构造函数都有一个关联的原型，并且该构造函数创建的每个对象都具有与其构造函数关联的原型（称为对象的原型）的隐式引用。此外，原型可能对其原型具有非无关隐式引用，依此类推。这称为原型链。

在基于类的对象语言中，通常是通过实例携带的状态，方法是通过类携带的，继承仅是结构和行为。在eCmascript中，状态和方法是由对象，结构，行为和状态均继承的。

原型是用于在Ecmascript中实现结构，状态和行为继承的对象。当构造函数创建一个对象时，该对象会隐式引用构造函数的关联原型，以解决属性引用。构造函数的关联原型可以通过程序表达式构造函数引用，并且可以通过继承共享对象原型的属性。

对于那些仍然认为 RFC 比博客和基于观点的误解更重要的人，让我们尝试回答澄清一些观点。我不会重复之前答案中已经提到的所有正确差异，在这里我只是尝试增加总结一些关键部分的价值 rfc7159

摘自 https://tools.ietf.org/html/rfc7159

JavaScript 目的符号（JSON）是用于序列化结构化数据的文本格式。它源自于目的JavaScript的文字，如Ecmascript编程语言标准中定义的，第三版[ECMA-262]。
JSON可以代表四种原始类型（字符串，数字，布尔值和null）和两种结构化类型（物体和数组）。
一个目的是零或更多名称/值对的无序集合，其中名称是字符串，值是字符串，数字，布尔值，null，目的, ，或数组。
开始对象 = ws %x7B ws ；{ 左大括号
最终对象 = ws %x7D ws ；} 右大括号
JSON 值必须是目的, ，数组，数字或字符串，或以下三个字面名称之一：假空真
一个目的结构表示为一对大括号
一个内的名字目的应该是独一无二的。目的 = 开始对象 [ 成员 *( 值分隔符成员 ) ] 最终对象
一个目的其名称都是唯一的，从某种意义上说，所有软件实现都接收到目的将同意名称值映射。当名称在目的不是唯一的，可以接收这样的软件的行为目的是不可预测的。

示例（来自 RFC 第 12 页）

这是一个 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]
          }
      }

它的 Image 成员是目的其缩略图成员是目的其IDS成员是数字数组。

确实不存在“JSON 对象”这样的东西。

真的吗？

据我了解，主要区别是 灵活性.

JSON是“ JavaScript对象符号”上的一种包装器，迫使用户遵守更严格的规则来定义对象。它通过限制JavaScript对象表示法提供的可能对象声明方式来实现此目的。

结果，我们拥有一个更简单，更标准化的对象，可更适合平台之间的数据交换。

因此，基本上，上面我的示例中的newObject是通过使用JavaScript objeect符号定义的对象。但这不是一个“有效”的JSON对象，因为它不遵循JSON标准所需的规则。

此链接也很有帮助：http://msdn.microsoft.com/en-us/library/bb299886.aspx

首先，您应该知道JSON是什么：

它是语言不可知的数据互换格式。 JSON的语法灵感来自JavaScript对象文字符号，但它们之间存在差异。

例如，在JSON中，必须引用所有键，而在对象文字中，这不是必需的：

// json：{“ foo”：“ bar”}

//对象文字：var o = {foo：“ bar”};引用在JSON上是强制性的，因为在JavaScript（更确切地说是Ecmascript3rd。版本中），将保留单词用作属性名称的用法不允许：例如：

var o = {if：“ foo”}; // ES3中的SyntaxError，使用字符串字面作为属性名称（引用属性名称）没有任何问题：

var o = {“ if”：“ foo”};因此，对于“兼容性”（也许很容易评估？），这些引号是强制性的。

JSON中的数据类型也仅限于以下值：

字符串编号对象数组的文字为：true false null字符串的语法变化。它们必须通过双引号界定，而在JavaScript中，您可以互换使用单个或双引号。

//无效的json：{“ foo”：'bar'}被接受的json数字语法也会更改，在JavaScript中，您可以使用十六进制文字，例如0xff，或（臭名昭著的）八分音字母，例如010。在json中，您可以使用只有十进制文字。

//无效JSON：{“ foo”：0xff}

JavaScript对象字面与JSON：

对象文字语法是创建JavaScript对象的非常方便的方法
这 JSON 代表“ JavaScript对象符号”的语言具有从JavaScript对象文字语法得出的语法。它用作编程语言独立的文本数据传输格式。

例子：

JS对象表示法，在JS中用于方便地在代码中创建对象：

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
}

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

主要差异：

JSON中的所有对象键都必须是字符串。在JavaScript对象中，键可以是字符串或数字
JSON中的所有字符串都必须在“双引号”中引用。而在JavaScript中，允许单引号和双引号。即使在JavaScript对象符号中没有引号，对象键也被隐式施放到字符串上。
在JSON中，一个函数不能定义为对象的值（因为这是JavaScript特定的）。在JavaScript中，这是完全合法的。

JavaScript构建 JSON 目的：

JSON 对象可以轻松地转换为JavaScript，反之亦然，使用内置 JSON JavaScript在其运行时提供的对象。例如：

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

这是一个令人惊讶的区别：您无法使用 undefined 在JSON和所有具有未定义值的对象字段中 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) );

🙈🙉🙊

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow