让我们首先澄清一下 JSON 到底是什么。JSON 是一种文本的、独立于语言的数据交换格式，与 XML、CSV 或 YAML 非常相似。

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

这种格式通常与语言无关，这意味着它们可以由 Java、Python、JavaScript、PHP 等进行处理。

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

举个反例，Python 有元组的概念，它们的语法是 .JavaScript 没有这样的东西。(x, y)

让我们看一下 JSON 和 JavaScript 对象字面量之间的语法差异。

JSON 具有以下语法约束：

• 对象键必须是字符串（即用双引号括起来的字符序列）。"
• 这些值可以是：
  • 字符串
  • 一个数字
  • （JSON） 对象
  • 数组
  • true
  • false
  • null
• 重复键 （） 会产生未定义的、特定于实现的结果;JSON规范没有具体定义它们的语义{"foo":"bar","foo":"baz"}

在 JavaScript 中，对象文字可以有

• 字符串文字、数字文字或标识符名称作为键（从 ES6 开始，现在也可以计算键，这引入了另一种语法）。
• 这些值可以是任何有效的 JavaScript 表达式，包括函数定义和 .undefined
• 重复键生成已定义的指定结果（在松散模式下，后一个定义将替换前一个定义;在严格模式下，这是一个错误）。

知道这一点，仅通过查看语法，您的示例就不是 JSON，原因有两个：

1. 键不是字符串（文本）。它们是标识符名称。
2. 不能将函数作为值分配给“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是“JavaScript对象表示法”的一种包装器，它迫使用户遵守更严格的规则来定义对象。它通过限制 JavaScript 对象表示法功能提供的可能的对象声明方式来实现这一点。

因此，我们有一个更简单、更标准化的对象，它更适合平台之间的数据交换。

所以基本上，我上面的例子中的 newObject 是使用 JavaScript Objeect Notation 定义的对象;但它不是一个“有效”的 JSON 对象，因为它不遵循 JSON 标准要求的规则。

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

根据 JavaScript 中的 JSON，

JSON 是对象的子集 JavaScript 的文字表示法。

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

正如 @Filix King 所建议的那样，除了阅读文档之外，我还建议使用 JSONLint 在线 JSON 验证器。这就是我如何了解到JSON对象的键必须是字符串。

实际上没有“JSON 对象”这样的东西。

JSON 规范是将数据编码为字符串的语法。人们所说的“JSON 对象”（在 javascript 中）实际上只是一个普通的 javascript 对象，它（可能）已经从有效的 JSON 字符串中反序列化，并且可以很容易地重新序列化为有效的 JSON 字符串。这通常意味着它只包含数据（而不是函数）。这也意味着没有日期，因为JSON没有日期类型（可能是JSON最痛苦的事情;)

此外，当人们谈论“JSON 对象”时，他们几乎总是指在顶层具有“大括号”的数据。这与 javascript 对象非常对应。但是，JSON 规范不要求在 JSON 字符串的顶层有一个“大括号”对象。在顶层有一个列表，甚至只有一个值，这是完全有效的 JSON。因此，虽然每个“JSON 对象”都对应于有效的 JSON，但并非所有有效的 JSON 字符串都对应于我们所说的“JSON 对象”！（因为字符串可以表示列表或原子值）

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

摘自 https://www.rfc-editor.org/rfc/rfc7159

1. JavaScript 对象表示法 （JSON） 是 结构化数据的序列化。它派生自 JavaScript 的对象文字，如 ECMAScript 编程中所定义 语言标准，第三版 [ECMA-262]。

2. JSON 可以表示四种基元类型（字符串、数字、布尔值、 和 null） 和两种结构化类型（对象和数组）。

3. 对象是零个或多个名称/值的无序集合 对，其中名称是字符串，值是字符串、数字、 boolean、null、object 或 array。

4. 开始对象 = ws %x7B ws ;{ 左大括号

5. end-object = ws %x7D ws ;} 右大括号

6. JSON 值必须是对象、数组、数字或字符串，或者是 以下三个文字名称： false null true

7. 对象结构表示为一对大括号

8. 对象中的名称应该是唯一的。object = begin-object [ member *（ value-separator member ） ] end-object

9. 从某种意义上说，名称都是唯一的对象是可互操作的 接收该对象的所有软件实现都将同意 名称-值映射。当对象中的名称不是 唯一，接收此类对象的软件的行为是 不可预知的。

10. 示例（来自 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 成员是一个对象，其 Thumbnail 成员是一个对象，并且 其 IDs 成员是数字数组。

实际上没有“JSON 对象”这样的东西。

真？

🔫 JSON：XML 的无脂替代品

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

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

JSON 对象是包含两个函数（parse 和 stringify）的单个对象，用于解析和构造 JSON 文本。

• JSON.stringify 生成符合以下 JSON 语法的 String。
• JSON.parse 接受符合 JSON 语法的 String。

parseJSON 方法将包含在 ECMAScript 的第四版中。同时，JavaScript 实现可在 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 是 JavaScript 的子集。Javascript 源自 ECMAScript 编程语言标准。

► ECMAScript 格式

ECMAScript 已发展成为世界上使用最广泛的通用编程语言之一。它最广为人知的是嵌入在 Web 浏览器中的语言，但也被广泛用于服务器和嵌入式应用程序。 ECMAScript基于几种原始技术，最著名的是JavaScript（Netscape Communications））和JScript（Microsoft Corporation）。虽然在1994年之前，ECMA被称为“欧洲计算机制造商协会”，但在1994年之后，当该组织成为全球性组织时，“商标”“Ecma”因历史原因被保留。

ECMAScript 是语言，而 JavaScript、JScript 甚至 ActionScript 都被称为“方言”。

方言源自同一种语言。它们彼此非常相似，因为它们源自同一种语言，但它们经历了一些变化。 方言是语言本身的变体。它源自一种语言。

• SQL 语言 - Hibernate MySQL 方言、Oracle 方言,..其中有一些更改或添加的功能。

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

navigator.appName // "Netscape"

ECMAScript 是构成 JavaScript 基础的脚本语言。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.

注意 « ECMAScript 的第 4 版未出版，因为该作品不完整。

JSON 为结构化数据的可移植表示定义了一小组格式规则。

1. ► 键值必须用引号括起来，键只允许使用字符串。如果您使用 String 以外的其他方法，它将转换为 String。但不建议使用 String 以外的键。检查这样的示例 - 通过 RFC 4627 - jsonformatter{ 'key':'val' }

    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 字符串必须用 “ 而不是 ' 引号括起来。字符串非常类似于 C 或 Java 字符串。字符串应用双引号括起来。

• 文本是您在脚本中实际提供的固定值，而不是变量。
• 字符串是用反斜杠擒纵机构用引号括起来的零个或多个字符的序列，与大多数编程语言中使用的符号相同。
• 🔫 - 字符串中允许使用特殊符号，但不建议使用。
• “ - 特殊字符可以转义。但不建议转义 （'） 单引号。 在严格模式下，它将抛出并出错 -SyntaxError: Unexpected token ' in JSON

通过在线 JSON 版本检查此代码。notStrictStrinct{ "Hai\" \n Team 🔫":5, "Bye \'": 7 }Modes , .

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

对象属性访问器通过使用点表示法或括号表示法提供对对象属性的访问。

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

    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 是一种动态类型语言。这意味着在声明变量时不必指定变量的数据类型，数据类型会在脚本执行期间根据需要自动转换。

文字：

'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

对象文本 RFC 7159

对象结构表示为一对大括号，将零个或多个名称/值对（或成员）括起来。名称是 字符串。每个名称后面都有一个冒号，将名称与值分隔开。一个逗号将一个值与一个值分隔开 名字。对象中的名称应该是唯一的。

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

在基于类的面向对象语言中，一般来说，状态由实例承载，方法由类承载，继承只是结构和行为。在 ECMAScript 中，状态和方法由对象承载，结构、行为和状态都是继承的。

原型是用于在 ECMAScript 中实现结构、状态和行为继承的对象。当构造函数创建对象时，该对象隐式引用构造函数的关联原型，以便解析属性引用。构造函数的关联原型可以 由程序表达式 constructor.prototype 引用，并且添加到对象原型的属性通过继承由共享原型的所有对象共享。

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

它是与语言无关的数据交换格式。 JSON 的语法受到 JavaScript Object Literal 表示法的启发，但它们之间存在差异。

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

JSON格式： { “foo”： “酒吧” }

对象文字： var o = { foo： “酒吧” }; 引号在 JSON 上是强制性的，因为在 JavaScript 中（更准确地说是在 ECMAScript 3rd. Edition 中），不允许使用保留字作为属性名称，例如：

var o = { if： “foo” };语法ES3 中的错误 虽然使用字符串文字作为属性名称（引用属性名称）没有问题：

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

JSON 中的数据类型也限制为以下值：

字符串 数 对象 数组 文字为： 真 假 零 字符串的语法发生了变化。它们必须用双引号分隔，而在 JavaScript 中，您可以交替使用单引号或双引号。

无效的 JSON： { “foo”： '酒吧' } Numbers 的公认 JSON 语法也发生了变化，在 JavaScript 中，您可以使用十六进制文字，例如 0xFF，或（臭名昭著的）八进制文字，例如 010。在 JSON 中，只能使用十进制文字。

无效的 JSON： { “foo”： 0xFF }

Javascript 对象文字与 JSON：

• 对象文字语法是创建 javascript 对象的一种非常方便的方法
• 该语言代表“Javascript 对象表示法”，其语法源自 javascript 对象文字语法。它被用作独立于编程语言的文本数据传输格式。JSON

例：

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 中，这是完全合法的。

JSON 对象中的 Javascript 构建：

JSON使用 Javascript 在其运行时提供的内置对象，可以很容易地将对象转换为 Javascript，反之亦然。例如：JSON

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

这里有一个令人惊讶的区别：你不能在 json 中使用，所有具有未定义值的对象字段将在undefinedJSON.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) );

🙈🙉🙊