Implementation of a simplified version of JSON.stringify and its six major features explained in detail

const obj = {
    bol: new Boolean(true),
    num: new Number(1),
    str: new String(1)
}

typeof obj.bol; // object
typeof obj.num; // object
typeof obj.str; // object

JSON.stringify(obj); // {"bol":true,"num":1,"str":"1"}

const stringifyObj = JSON.parse(JSON.stringify(obj));
typeof stringifyObj.bol; // boolean
typeof stringifyObj.num; // number
typeof stringifyObj.str; // string

const obj = {
    nan: NaN,
    infinity: Infinity,
    null: null,
};

JSON.stringify(obj); // {"nan":null,"infinity":null,"null":null}

const obj = {
    nan: NaN,
    infinity: Infinity,
    null: null,
    toJSON() {
        return "has toJSON function";
    },
};

JSON.stringify(obj); // "has a toJSON function"

const obj = {
    date: new Date(),
};

JSON.stringify(obj); // {"date":"2021-10-08T11:43:31.881Z"}

const obj = {
    undefined: undefined,
    fn() {},
    symbol: Symbol()
};

JSON.stringify(obj); // {}

const fn = function () {};
const obj = {
    [undefined]: undefined,
    [fn]: function () {},
    [Symbol()]: Symbol()
};

JSON.stringify(obj); // {}

const arr = [undefined, function fn() {}, Symbol()];

JSON.stringify(arr); // [null,null,null]

JSON.stringify(undefined); // undefined
JSON.stringify(function () {}); // undefined
JSON.stringify(Symbol()); // undefined

const obj = {
    name: "nordon",
    age: 18,
};

// Change age to a non-enumerable property Object.defineProperty(obj, "age", {
    enumerable: false,
});

JSON.stringify(obj); // {"name":"nordon"}

const obj = {
    name: "nordon",
    age: 18,
};

const p = {
    name: 'wy',
    obj
}

obj.p = p

JSON.stringify(obj);

const currying = (fn, ...outParams) => {
    // Get the number of parameters required by the fn function const paramsLen = fn.length;

    return (...args) => {
        // Collect all parameters let params = [...outParams, ...args];
        // If the parameters do not reach the parameters required by fn, continue to collect parameters if (params.length < paramsLen) {
            return currying(fn, ...params);
        }

        return fn(...params);
    };
};

/**
 * type: type - [object Array], [object Number], etc. * source: data source */
const judgeType = (type, source) => {
    return Object.prototype.toString.call(source) === type;
};

const isUndefined = currying(judgeType, "[object Undefined]");
const isSymbol = currying(judgeType, "[object Symbol]");
const isFunction = currying(judgeType, "[object Function]");
const isObject = currying(judgeType, "[object Object]");
const isNull = currying(judgeType, "[object Null]");

function jsonStringify(data) {
    let type = typeof data;

    if (isNull(data)) { 
// null directly returns the string 'null'
        return "null";
    } else if (data.toJSON && typeof data.toJSON === "function") {
// Configure the toJSON function, directly use the data returned by toJSON and ignore other data return jsonStringify(data.toJSON());
    } else if (Array.isArray(data)) {
        let result = [];
        //If it is an array, then each item in the array may be of different types data.forEach((item, index) => {
            if (isUndefined(item) || isSymbol(item) || isFunction(item)) {
                result[index] = "null";
            } else {
                result[index] = jsonStringify(item);
            }
        });

        result = "[" + result + "]";

        return result.replace(/'/g, '"');
    } else if (isObject(data)) {
        // Processing ordinary objects let result = [];
        Object.keys(data).forEach((item, index) => {
            if (typeof item !== "symbol") {
                //If key is a symbol object, ignore if (
                    data[item] !== undefined &&
                    typeof data[item] !== "function" &&
                    typeof data[item] !== "symbol"
                ) {
                    //If the key value is undefined, function, or symbol, ignore result.push(
                        '"' + item + '"' + ":" + jsonStringify(data[item])
                    );
                }
            }
        });

        return ("{" + result + "}").replace(/'/g, '"');
    } else if (type !== "object") {
        let result = data;

        //data may be a basic data type, handle it here if (Number.isNaN(data) || data === Infinity) {
            //NaN and Infinity serialization returns "null"
            result = "null";
        } else if (isUndefined(data) || isSymbol(data) || isFunction(data)) {
            // Since function serialization returns undefined, it is processed together with undefined and symbol return undefined;
        } else if (type === "string") {
            result = '"' + data + '"';
        }

        return String(result);
    }
}