JSON.stringify和JSON.parse

在真正去实现JSON.stringify的时候，我们先来关注一下，JSON.stringify函数的功能都有那些？只有真正懂得来JSON.stringify函数的功能，我们才能自己去实现一下JSON.stringify函数。

JSON.stringfy() 的说明

JSON.stringify()方法是将一个JavaScript值(对象或者数组)转换为一个 JSON字符串，如果指定了replacer是一个函数，则可以选择性的替换值，或者如果指定了replacer是一个数组，可选择性的仅包含数组指定的属性。
本文要实现的JSON.stringfy()是不带replacer和space参数的简化版本

转化过程遵循以下原则

• 转换值如果有toJSON()方法，该方法定义什么值将被序列化。
• 非数组对象的属性不能保证以特定的顺序出现在序列化后的字符串中。
• 布尔值、数字、字符串的包装对象在序列化过程中会自动转换成对应的原始值。
• undefined、任意的函数以及 symbol 值，在序列化过程中会被忽略（出现在非数组对象的属性值中时）或者被转换成null（出现在数组中时）。函数、undefined被单独转换时，会返回undefined，如JSON.stringify(function(){})orJSON.stringify(undefined).
• 对包含循环引用的对象（对象之间相互引用，形成无限循环）执行此方法，会抛出错误。
• 所有以 symbol 为属性键的属性都会被完全忽略掉，即便replacer参数中强制指定包含了它们。
• Date日期调用了toJSON()将其转换为了string字符串（同Date.toISOString()），因此会被当做字符串处理。
• NaN和Infinity格式的数值及null都会被当做null。
• 其他类型的对象，包括Map/Set/weakMap/weakSet，仅会序列化可枚举的属性。

  转化例子

  ```javascript JSON.stringify({}); // ‘{}’ JSON.stringify(true); // ‘true’ JSON.stringify(“foo”); // ‘“foo”‘ JSON.stringify([1, “false”, false]); // ‘[1,”false”,false]’ JSON.stringify({ x: 5 }); // ‘{“x”:5}’

JSON.stringify({x: 5, y: 6});
// “{“x”:5,”y”:6}”

JSON.stringify([new Number(1), new String(“false”), new Boolean(false)]); // ‘[1,”false”,false]’

JSON.stringify({x: undefined, y: Object, z: Symbol(“”)}); // ‘{}’

JSON.stringify([undefined, Object, Symbol(“”)]);
// ‘[null,null,null]’

JSON.stringify({[Symbol(“foo”)]: “foo”});
// ‘{}’

JSON.stringify({[Symbol.for(“foo”)]: “foo”}, [Symbol.for(“foo”)]); // ‘{}’

JSON.stringify( {[Symbol.for(“foo”)]: “foo”}, function (k, v) { if (typeof k === “symbol”){ return “a symbol”; } } );

// undefined

// 不可枚举的属性默认会被忽略： JSON.stringify( Object.create( null, { x: { value: ‘x’, enumerable: false }, y: { value: ‘y’, enumerable: true } } ) ); // “{“y”:”y”}”

<a name="uLEXT"></a>
## 知道执行的过程后, 如何手写一个JSON.stringify方法. 就变的很容易了.
代码如下:
```javascript
/**
 * 手写源码：JSON.parse和JSON.stringify(不带replacer和space参数的简化版本)
 */
 const JSON = {
    parse: function(jsonStr) {
        return eval(`(${jsonStr})`);
    },
    stringify: function(jsonStr) {
        switch(Object.prototype.toString.call(jsonStr)) {
            case '[object Null]':
            case '[object Boolean]':
            case '[object Number]':
                return String(jsonStr)==="NaN" ? String(null) : String(jsonStr);
            case '[object String]':
            case '[object Date]':
                return `"${jsonStr.toJSON ? jsonStr.toJSON() : jsonStr.toString()}"`;
            case '[object Object]':
                let resultObj = '{';
                for(key in jsonStr) {
                    if(this.stringify(key) !== undefined && this.stringify(jsonStr[key]) !== undefined) {
                        resultObj += `"${key}":${this.stringify(jsonStr[key])},`;
                    }
                }
                resultObj = resultObj.length > 1? resultObj.slice(0, -1): resultObj;
                return resultObj += '}';
            case '[object Array]': 
                let resultArr = '[';
                for(item of jsonStr) {
                    resultArr += (this.stringify(item) === undefined ? null : this.stringify(item)) + ",";
                }
                resultArr = resultArr.length > 1? resultArr.slice(0, -1): resultArr;
                return resultArr += ']';
            case '[object Set]':
            case '[object Map]':
            case '[object RegExp]':
                return "{}";
            case '[object Undefind]':
            case '[object Function]': 
            case '[object Symbol]':
                return undefined;
        }
    }
}

测试一下.

// 测试后发现以下与原生体现不符，没搞明白为什么
JSON.stringify(
    {[Symbol.for("foo")]: "foo"}, 
    function (k, v) {
        if (typeof k === "symbol"){
            return "a symbol";
        }
    }
);
//原生: undefined, 我的实现："{}"

我们发现原生序列化和自实现的返回值, 不一样

参考文章（拷贝文章）

手写源码系列（三）——JSON.stringfy和JSON.parse
MDN之JSON.stringify