不得不会的JSON.parse和Json

不得不会的JSON.parse()和JSON.stringfy()

前言

前端面试过程中以及日常开发过程中，我们都不能避免对数据进行处理和分析，将其使用到我们所设计的代码之中，而JSON.parse()和JSON.stringfy()便是其中较为重要的一种。两者通常用作Json对象和字符串之间的相互转换。

（一）、Json.parse(text,[,revivier])

参数说明：

• text：必须，一个有效的json字符串；
• reviver：可选，一个转换结果的函数，将为对象的每个成员调用此函数；

返回值：
返回传入字符串经过第二个参数转换后的对象。
例子：

const user = {
  name: 'John',
  email: 'john@awesome.com',
  plan: 'Pro'
};

const userStr = JSON.stringify(user);

const newUserStr = JSON.parse(userStr, (key, value) => {
  if (typeof value === 'string') {
    return value.toUpperCase();
  }
  return value;
});

控制台输出结果：

(二)、Json.stringfy(value,[,replacer[,space]])

参数说明：

• value:必须，要进行转换的数组或者是对象；
• replacer：用于转换结果的函数或数组。
  如果 replacer 为函数，则 JSON.stringify 将调用该函数，并传入每个成员的键和值。使用返回值而不是原始值。如果此函数返回 undefined，则排除成员。根对象的键是一个空字符串：""。
  如果 replacer 是一个数组，则仅转换该数组中具有键值的成员。成员的转换顺序与键在数组中的顺序一样。
  space:可选，文本添加缩进、空格和换行符，如果 space 是一个数字，则返回值文本在每个级别缩进指定数目的空格，如果 space 大于 10，则文本缩进 10 个空格。space 也可以使用非数字，如：\t。

返回值：
返回包含 JSON 文本的字符串。

替换函数可以用来过滤值，因为任何返回 undefined 的值将不在返回的字符串中：

const user = {
  id: 229,
  name: 'John',
  email: 'john@awesome.com'
};
 
function replacer(key, value) {
  console.log(typeof value);
  if (key === 'email') {
    return undefined;
  }
  return value;
}
 
const userStr = JSON.stringify(user, replacer);

控制台结果：

若使用第三个参数，例：const userStr = JSON.stringfy(user,replacer,'...')
得到：

（三）、toJson方法

如果一个被序列化的对象拥有 toJSON 方法，那么该 toJSON 方法就会覆盖该对象默认的序列化行为：不是那个对象被序列化，而是调用 toJSON 方法后的返回值会被序列化。

var obj = {
    foo: 'foo',
    toJSON:function(){
        return 'bar';
    }
}

利用toJSON方法,我们可以修改对象转换成JSON的默认行为。

(四)、用 JSON.stringify 来格式化对象

实际应用中，会遇到对象里面还会嵌套对象，因此不能用常规的直接的运用：

var censor = function(key,value){
    if(typeof(value) == 'function'){
         return Function.prototype.toString.call(value)
    }
    return value;
}
var foo = {bar:"1",baz:3,o:{name:'xiaoli',age:21,info:{sex:'男',getSex:function(){return 'sex';}}}};
console.log(JSON.stringfy(foo))
console.log(JSON.stringify(foo,censor,4))

控制台：

实际返回的是字符串！！（注意）

关于JSON.parse(JSON.stringify(obj))实现深拷贝应该注意的坑

JSON.parse(JSON.stringify(obj))我们一般用来深拷贝，其过程说白了 就是利用JSON.stringify 将js对象序列化（JSON字符串），再使用JSON.parse来反序列化(还原)js对象；序列化的作用是存储(对象本身存储的只是一个地址映射，如果断电，对象将不复存在，因此需将对象的内容转换成字符串的形式再保存在磁盘上 )和传输（例如 如果请求的Content-Type是 application/x-www-form-urlencoded，则前端这边需要使用qs.stringify(data)来序列化参数再传给后端，否则后端接受不到； ps: Content-Type为 application/json;charset=UTF-8或者 multipart/form-data则可以不需要 ）；我们在使用 JSON.parse(JSON.stringify(xxx))时应该注意一下几点：
1、如果obj里面有时间对象，则JSON.stringify后再JSON.parse的结果，时间将只是字符串的形式。而不是时间对象；
例子：

var test = {
        name: 'a',
        date: [new Date(1536627600000), new Date(1540047600000)],
      };

      let b;
      b = JSON.parse(JSON.stringify(test))

结果：


2、如果obj里有RegExp、Error对象，则序列化的结果将只得到空对象；

const test = {
        name: 'a',
        date: new RegExp('\\w+'),
      };
      // debugger
      const copyed = JSON.parse(JSON.stringify(test));
      test.name = 'test'
      console.error('ddd', test, copyed)

3、如果obj里有函数，undefined，则序列化的结果会把函数或 undefined丢失；

const test = {
        name: 'a',
        date: function hehe() {
          console.log('fff')
        },
      };
      // debugger
      const copyed = JSON.parse(JSON.stringify(test));
      test.name = 'test'
      console.error('ddd', test, copyed)

4、如果obj里有NaN、Infinity和-Infinity，则序列化的结果会变成null；

5、JSON.stringify()只能序列化对象的可枚举的自有属性，例如 如果obj中的对象是有构造函数生成的， 则使用JSON.parse(JSON.stringify(obj))深拷贝后，会丢弃对象的constructor

 function Person(name) {
        this.name = name;
        console.log(name)
      }

      const liai = new Person('liai');

      const test = {
        name: 'a',
        date: liai,
      };
      // debugger
      const copyed = JSON.parse(JSON.stringify(test));
      test.name = 'test'
      console.error('ddd', test, copyed)

6、如果对象中存在循环引用的情况也无法正确实现深拷贝；

以上，如果拷贝的对象不涉及上面讲的情况，可以使用JSON.parse(JSON.stringify(obj))实现深拷贝，但是涉及到上面的情况，可以考虑使用如下方法实现深拷贝：

function  deepClone(data) {
      const type = this.judgeType(data);
      let obj;
      if (type === 'array') {
        obj = [];
      } else if (type === 'object') {
        obj = {};
      } else {
    // 不再具有下一层次
        return data;
      }
      if (type === 'array') {
        // eslint-disable-next-line
        for (let i = 0, len = data.length; i < len; i++) {
          obj.push(this.deepClone(data[i]));
        }
      } else if (type === 'object') {
        // 对原型上的方法也拷贝了....
        // eslint-disable-next-line
        for (const key in data) {
          obj[key] = this.deepClone(data[key]);
        }
      }
      return obj;
    },


function  judgeType(obj) {
  // tostring会返回对应不同的标签的构造函数
      const toString = Object.prototype.toString;
      const map = {
        '[object Boolean]': 'boolean',
        '[object Number]': 'number',
        '[object String]': 'string',
        '[object Function]': 'function',
        '[object Array]': 'array',
        '[object Date]': 'date',
        '[object RegExp]': 'regExp',
        '[object Undefined]': 'undefined',
        '[object Null]': 'null',
        '[object Object]': 'object',
      };
      if (obj instanceof Element) {
        return 'element';
      }
      return map[toString.call(obj)];
    },