JSON和JavaScript对象互转

JSON的本质是一个字符串,它之所以受欢迎,是因为可以把JSON字符串解析为有用的JavaScript对象。

ECMAScript5中,对解析JSON的行为进行了规范,并定义了一个全局对象JSON,该对象有两个方法:JSON.parse() 和 JSON.stringify()。

JSON.parse()

JSON.parse() 方法,用于把JSON字符串转换为原生的 JavaScript 值或对象。如:

  1. JSON.parse('1')      // 1
  2. JSON.parse('{}')      // {}
  3. JSON.parse('true')    // true
  4. JSON.parse('"foo"')   // "foo"
  5. JSON.parse('[1, 5, "false"]')   // [1, 5, "false"]
  6. JSON.parse('null')    // null
  7. var o = JSON.parse('{"name": "张三"}');
  8. o.name   // 张三

如果传递给JSON.parse()方法的字符串不是有效的JSON格式,JSON.parse()方法将报错。如:

  1. JSON.parse("'String'")
  2. //Uncaught SyntaxError: Unexpected token u in JSON at position 0(…)
  3.  
  4. JSON.parse("undefined")
  5. //Uncaught SyntaxError: Unexpected token u in JSON at position 0(…)

除了直接进行字符串转换之外,JSON.parse()方法也可以接收一个函数参数,该函数被称为还原函数。如果提供还原函数,则对象的每个成员都会调用这个函数。

还原函数接收两个参数,一个键和一个值,并返回一个值。如果还原函数返回undefined,则表示要从结果中删除相应的键;如果返回其他值,则将该值插入到结果中。如:

  1. var o = JSON.parse('{"a":1,"b":2}', function(key, value) {
  2.   if (key === ''){
  3.     return value;
  4.   }
  5.   if (key === 'a') {
  6.     return value + 10;
  7.   }
  8. });
  9. o.a // 11
  10. o.b // undefined

JSON 不能存储 Date 对象。如果你需要存储 Date 对象,需要将其转换为字符串,之后再将字符串转换为 Date 对象。在将日期字符串转换为Date对象时,经常要用到还原函数。如:

  1. var book = {
  2.   "title": "javascript",
  3.   "date": new Date(2018,1,21)
  4. }
  5. var jsonStr = JSON.stringify(book);
  6. console.log(jsonStr)
  7. //'{"title":"javascript","date":"2018-02-20T16:00:00.000Z"}'
  8.  
  9. var bookCopy = JSON.parse(jsonStr,function(key,value){
  10.   if(key == 'date'){
  11.     return new Date(value);
  12.   }
  13.   return value;
  14. })
  15. console.log(bookCopy.date.getFullYear());  //2018

说明:JSON.parse() 和 eval()

实际上,eval() 函数的功能类似于 JSON.parse()方法,也可以将json字符串转换为json对象。如:

  1. eval('(' + '{"a":1}'+')').a;  //1
  2. JSON.parse('{"a":1}').a;     //1

但是,eval() 函数可以执行不符合 JSON 格式的代码。如:

  1. eval('(' + '{"a":alert(1)}'+')').a;  //弹出1
  2. JSON.parse('{"a":alert(1)}').a;     //报错

在浏览器中运行上述代码,eval() 函数就会弹出 alert 框,而 JSON.parse()方法将会报错。由于 eval() 函数会为恶意代码提供可乘之机,因此应当尽量少使用 eval() 函数,而是使用更安全的 JSON.parse()方法。

JSON.stringify()

JSON.stringify()方法用于把JavaScript值(对象或者数组)序列化为JSON字符串,并返回序列化后的JSON字符串。调用格式为:

JSON.stringify(value[, replacer[, space]])

参数:

value: 必需。将要序列化为JSON 字符串的值。

replacer: 可选。用于替换结果的函数、或仅包括指定的属性数组。

space: 可选。用于文本添加缩进、空格和换行符。

序列化规则

序列化的本质,就是按照 JSON 的语法规则,把 JavaScript 值(对象或者数组),转换为 JSON 字符串,以方便存储和数据交换。

1)数值、布尔值、字符串的包装对象,会转换成对应的原始值。如:

  1. JSON.stringify(1)      // "1"
  2. JSON.stringify(false)   // "false"
  3. JSON.stringify('abc')   // ""abc""
  4. JSON.stringify([1, "false", false])  // '[1,"false",false]'

2)键和值都被序列化,如果键名没有引号,会自动为它添加引号。如:

  1. JSON.stringify({x: 5, y: 6});     // "{"x":5,"y":6}"
  2. JSON.stringify({name: "张三"})    // '{"name":"张三"}'

3)数组,会转换成数组格式。如:

  1. JSON.stringify([])   // "[]"
  2. JSON.stringify([1, "false", false])  // '[1,"false",false]'

4)对象,会转换成对象格式。如:

  1. JSON.stringify({})   // "{}"
  2. JSON.stringify({x: 5, y: 6});     // "{"x":5,"y":6}"

5)正则表达式和数学对象,转换成空对象的字符串形式。如:

  1. JSON.stringify(/foo/)   // "{}"
  2. JSON.stringify(Math)  // "{}"

6)日期对象和包装对象,转换成字符串。如:

  1. JSON.stringify(new Boolean(true))  //"true"
  2. JSON.stringify(new String('123'))   //""123""
  3. JSON.stringify(new Number(1))    //"1"
  4. JSON.stringify(new Date())        //""2016-09-20T02:26:38.294Z""

7) 如果非数组对象的成员是undefined、或任意的函数、或 symbol 值,这个成员会被省略。如果数组对象的成员是undefined、或任意的函数、或 symbol 值,则这些值被转成null。如:

  1. JSON.stringify({
  2.   a: function(){},
  3.   b: undefined,
  4.   c: [ function(){}, undefined ]
  5. });
  6. // "{"c":[null,null]}"

8)不可枚举的属性,会被忽略。如:

  1. var obj = {};
  2. Object.defineProperties(obj, {
  3.   'foo': { value: 1,  enumerable: true },
  4.   'bar': { alue: 2, enumerable: false }
  5. });
  6. JSON.stringify(obj);  // "{"foo":1}"

9)所有以 symbol 为键的属性都会被完全忽略掉,即便 replacer 参数中强制指定包含了它们。如:

  1. JSON.stringify(
  2.     {[Symbol.for("foo")]: "foo"},
  3.     function (k, v) {
  4.         if (typeof k === "symbol"){
  5.             return "a symbol";
  6.         }
  7.     }
  8. );
  9. // undefined

replacer参数

replacer参数可以是一个函数或者一个数组。

1)函数

如果replacer参数是一个函数,则对象的每个成员都会调用这个函数。该函数接收两个参数,一个是键(key),一个是值(value),执行序列化时,键和值都会被序列化。如:

  1. function dobule(key, value){
  2.   if (typeof value === "number") {
  3.     value = 2 * value;
  4.   }
  5.   return value;
  6. }
  7. console.log(JSON.stringify({a:1,b:2}, dobule()));  // "{"a":2,"b":4}"

如果replacer函数返回的是一个对象,则该对象被递归地序列化成JSON字符串,并且允许键为空。如:

  1. var jsonObj = {a: {b: 1}};
  2. JSON.stringify(jsonObj, function(key, value) {
  3.   console.log("["+ key +"]:" + value);
  4.   return value;
  5. });

上述代码中,对象 jsonObj 一共会被 function函数处理三次。第一次键名为空,键值是整个对象 jsonObj;第二次键名为 a,键值是 {b:1};第三次键名为 b,键值为 1。运行结果为:

  1. []:[object Object]
  2. [a]:[object Object]
  3. [b]:1

如果replacer函数返回了undefined或没有返回值,那么相应的属性会被忽略,这种情况将不会被序列化成JSON字符串。如:

  1. JSON.stringify({ a: "abc", b: 123 }, function (key, value) {
  2.   if (typeof(value) === "string") {
  3.     return undefined;
  4.   }
  5.   return value;
  6. })

上述代码得到的结果为:

  1. '{"b": 123}'

2)数组

如果replacer是一个数组,数组的值代表将被序列化成JSON字符串的属性名。执行序列化时,则只对数组中所列举的键执行序列化操作,就相当于实现一个过滤器的功能。如:

  1. var jsonObj = {
  2.   "title":"javascript",
  3.   "group":{
  4.     "a":1,
  5.     "b":2
  6.   }
  7. };
  8. console.log(JSON.stringify(jsonObj,["group","b"]))

上述代码的运行结果为:

  1. {"group":{"b":2}}

需要特别说明的是,过滤器功能只适用于对象,对数组无效。如,

  1. var jsonObj = [1,2];
  2. console.log(JSON.stringify(jsonObj,["0"]));   // "[1,2]"

space参数

默认情况下,JSON.stringify() 输出的JSON字符串不包括任何空格字符或缩进。如:

  1. var jsonObj = {
  2.     "title":"javascript",
  3.     "group":{
  4.         "name":"jia",
  5.         "tel":12345
  6.     }
  7. };
  8. JSON.stringify(jsonObj);
  9. //{"title":"javascript","group":{"name":"jia","tel":12345}}

通过指定space参数,可以在JSON字符串中添加空格或字符串,用于增加返回的JSON字符串的可读性。space参数的值可以是数值或字符串。

1)数值

如果space参数的值是数值,则序列化的字符串中,每一级别会比上一级别缩进指定数目的空格(不超过10个空格)。如:

  1. console.log(JSON.stringify({ p1: 1, p2: 2 }, null, 2));

上述代码得到的结果为:

  1. {
  2.   "p1": 1,
  3.   "p2": 2
  4. }

2)字符串

如果space参数的值是字符串(字符串不超过10个字符),则序列化的字符串中,每一级别会比上一级别的缩进,使用该字符串填充。如:

  1. console.log(JSON.stringify({ p1:1, p2:2 }, null, '|-'));

上述代码得到的结果为:

  1. {
  2. |-"p1": 1,
  3. |-"p2": 2
  4. }

注意:

在序列化一个对象时,如果该对象拥有 toJSON()方法,那么该 toJSON() 方法就会覆盖该对象默认的序列化行为: 被序列化的不是那个原始对象,而是调用 toJSON() 方法后返回的那个对象。如:

  1. var obj = {
  2.   foo: 'foo',
  3.   toJSON: function () {
  4.     return 'bar';
  5.   }
  6. };
  7. JSON.stringify(obj);       // '"bar"'
  8. JSON.stringify({x: obj});   // '{"x":"bar"}'

如果 toJSON()方法返回 undefined,此时如果包含它的对象嵌入在另一个对象中,会导致该对象的值变成 null。而如果包含它的对象是顶级对象,结果就是 undefined。

Date 对象部署了一个自己的 toJSON()方法,它会自动将 Date 对象转换成日期字符串。如:

  1. JSON.stringify(new Date("2017-12-29"))
  2. // "2017-12-29T00:00:00.000Z"

关于作者

歪脖先生,十五年以上软件开发经验,酷爱Web开发,精通 HTML、CSS、JavaScript、jQuery、JSON、Python、Less、Bootstrap等,著有《HTML宝典》、《揭秘CSS》、《Less简明教程》、《JSON教程》、《Bootstrap2用户指南》、《Bootstrap3实用教程》,并全部在 GitHub 上开源。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 成长之路 设计师:Amelia_0503 返回首页