244

有人能告诉我使用Object Literal Notation定义的 JavaScript 对象和JSON 对象之间的主要区别是什么吗？

根据一本 JavaScript 书，它说这是一个使用Object Notation定义的对象：

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

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

4

10 回答 10

278

让我们首先澄清一下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，原因有两个：

  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 对象”之类的东西。

于 2010-05-25T11:42:45.097 回答
47

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

  • 必须引用键值
  • 字符串必须用"而不是用引号引起来'
  • 您的值范围更有限（例如，不允许使用函数）
于 2010-05-25T11:45:03.230 回答
17

真的没有“JSON 对象”这样的东西。

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

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

于 2011-12-14T15:55:07.423 回答
9

根据JavaScript 中的 JSON，

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

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

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

于 2011-02-16T03:13:05.703 回答
5

JSON：XML 的无脂肪替代品

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

► JavaScript Object Notation ( JSON) 是一种轻量级的、基于文本的、独立于语言的数据交换格式。JSON 已被用于在以任何编程语言编写的应用程序之间交换数据。

JSON 对象是一个包含两个函数（parse 和 stringify）的单个对象，用于解析和构造 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（Microsoft Corporation）。）。尽管在 1994 年之前，ECMA 被称为“欧洲计算机制造商协会”，但在 1994 年之后，当该组织走向全球时，“商标”“ECMA”由于历史原因而被保留。

ECMAScript 是一种语言，而 JavaScript、JScript 甚至 ActionScript 都称为"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第 4 版由于工作不完整而未发布。

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

  1. ► 必须引用键值，键只允许使用字符串。如果您使用 String 以外的内容，它将转换为 String。但不建议使用字符串以外的键。检查一个这样的例子 -{ '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() {}' ] );

  2. ► JSON 字符串必须用 " 而不是 ' 引用。字符串与 C 或 Java 字符串非常相似。字符串应该用双引号括起来。

  • 文字是您在脚本中按字面提供的固定值，而不是变量。
  • 字符串是由带有反斜杠转义的引号包裹的零个或多个字符的序列，与大多数编程语言中使用的符号相同。
  • - 字符串中允许使用特殊符号，但不建议使用。
  • " - 可以转义特殊字符。但不建议转义 (') 单引号。在严格模式下，它会抛出错误 -SyntaxError: Unexpected token ' in JSON

{ "Hai\" \n Team ":5, "Bye \'": 7 }通过在线 JSON 版本检查此代码。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"}

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

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

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

于 2017-08-09T13:53:06.540 回答
1

据我了解，主要区别在于灵活性。

JSON 是“JavaScript Object Notation”的一种包装器，它强制用户遵守更严格的规则来定义对象。它通过限制 JavaScript Object Notation 特性提供的可能的对象声明方式来做到这一点。

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

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

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

于 2010-05-25T12:06:14.883 回答
1

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

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

  1. JavaScript Object Notation (JSON) 是一种用于结构化数据序列化的文本格式。它源自 JavaScript 的对象 文字，如 ECMAScript 编程语言标准，第三版 [ECMA-262] 中所定义。

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

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

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

  5. 最终对象 = ws %x7D ws ; } 右花括号

  6. JSON 值必须是对象、数组、数字或字符串，或以下三个文字名称之一： false null tr​​ue

  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 对象”这样的东西。

真的吗？

于 2016-08-10T12:44:45.600 回答
0

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

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

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

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

// 对象字面量：var o = { foo: "bar" }; JSON 中的引号是强制性的，因为在 JavaScript 中（更确切地说，在 ECMAScript 3rd. Edition 中），不允许使用保留字作为属性名称，例如：

var o = { if: "foo" }; // ES3 中的 SyntaxError 虽然，使用字符串文字作为属性名（引用属性名）没有问题：

var o = { "如果": "foo" }; 因此，对于“兼容性”（也许是简单的评估？），引号是强制性的。

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

字符串数字对象数组字面量为：true false null Strings 的语法发生变化。它们必须用双引号分隔，而在 JavaScript 中，您可以互换使用单引号或双引号。

// Invalid JSON: { "foo": 'bar' } 可接受的 JSON 数字语法也发生了变化，在 JavaScript 中，您可以使用十六进制文字，例如 0xFF，或（臭名昭著的）八进制文字，例如 010。在 JSON 中，您可以使用只有十进制文字。

// 无效的 JSON: { "foo": 0xFF }

于 2018-05-14T10:05:39.160 回答
0

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对象：

JSONJSON使用Javascript 在其运行时提供的内置对象可以轻松地将对象转换为 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

于 2019-06-11T07:37:10.207 回答
0

这是一个令人惊讶的区别：您不能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) );

于 2019-06-19T18:18:06.077 回答