JSON.stringify の簡易版の実装とその 6 つの主要機能の詳細な説明

定数オブジェクト = {
    bol: 新しいブール値(true)、
    num: 新しい数値(1)、
    str: 新しい文字列(1)
}

typeof obj.bol; // オブジェクト
typeof obj.num; // オブジェクト
typeof obj.str; // オブジェクト

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

JSON を解析して文字列を解析する
typeof stringifyObj.bol; // ブール値
typeof stringifyObj.num; // 数値
typeof stringifyObj.str; // 文字列

定数オブジェクト = {
    ナン: NaN、
    無限: 無限、
    ヌル: ヌル、
};

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

定数オブジェクト = {
    ナン: NaN、
    無限: 無限、
    ヌル: ヌル、
    JSON() {
        「toJSON関数があります」を返します。
    },
};

JSON.stringify(obj); // "toJSON関数があります"

定数オブジェクト = {
    日付: 新しい Date(),
};

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

定数オブジェクト = {
    未定義: 未定義、
    関数fn() {},
    シンボル: シンボル()
};

JSON.stringify(obj); // {}

定数fn = 関数（）{};
定数オブジェクト = {
    [未定義]: 未定義、
    [関数]: 関数() {},
    [シンボル()]: シンボル()
};

JSON.stringify(obj); // {}

const arr = [未定義、関数fn() {}、シンボル()];

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

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

定数オブジェクト = {
    名前: "nordon",
    年齢: 18歳
};

// 年齢を列挙不可能なプロパティに変更する Object.defineProperty(obj, "age", {
    列挙可能: false、
});

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

定数オブジェクト = {
    名前: "nordon",
    年齢: 18歳
};

定数p = {
    名前: 'wy',
    オブジェクト
}

オブジェクトp = p

JSON.stringify(obj);

const カリー化 = (fn, ...outParams) => {
    // fn 関数に必要なパラメータの数を取得します。const paramsLen = fn.length;

    戻り値 (...引数) => {
        // すべてのパラメータを収集します。let params = [...outParams, ...args];
        // パラメータがfnに必要なパラメータに達しない場合は、パラメータの収集を続けます。if (params.length < paramsLen) {
            カリー化(fn, ...params)を返します。
        }

        fn(...params) を返します。
    };
};

/**
 * type: タイプ - [オブジェクト配列]、[オブジェクト番号]など。 * source: データソース */
const judgeType = (type, source) => {
    Object.prototype.toString.call(source) === type を返します。
};

const isUndefined = currying(judgeType, "[オブジェクト Undefined]");
const isSymbol = currying(judgeType, "[オブジェクト シンボル]");
const isFunction = currying(judgeType, "[オブジェクト Function]");
const isObject = currying(judgeType, "[object Object]");
const isNull = currying(judgeType, "[オブジェクト Null]");

関数jsonStringify(データ) {
    type = typeofデータとします。

    if (isNull(データ)) { 
// null は直接文字列 'null' を返します
        「null」を返します。
    } そうでない場合 (data.toJSON && typeof data.toJSON === "function") {
// toJSON 関数を設定し、toJSON によって返されたデータを直接使用し、他のデータは無視します return jsonStringify(data.toJSON());
    } そうでない場合 (Array.isArray(data)) {
        結果 = [] とします。
        //配列の場合、配列内の各項目は異なる型である可能性があります data.forEach((item, index) => {
            if (isUndefined(item) || isSymbol(item) || isFunction(item)) {
                結果[インデックス] = "null";
            } それ以外 {
                結果[インデックス] = jsonStringify(item);
            }
        });

        結果 = "[" + 結果 + "]";

        結果を返します。replace(/'/g, '"');
    } そうでない場合 (isObject(データ)) {
        // 通常のオブジェクトを処理する let result = [];
        Object.keys(data).forEach((item, index) => {
            if (typeof item !== "シンボル") {
                //キーがシンボルオブジェクトの場合、if(を無視する
                    データ[項目] !== 未定義 &&
                    typeof data[item] !== "function" &&
                    typeof data[item] !== "symbol"
                ）{
                    //キー値が未定義、関数、またはシンボルの場合は無視します。result.push(
                        '"' + 項目 + '"' + ":" + jsonStringify(data[item])
                    );
                }
            }
        });

        戻り値: ("{" + 結果 + "}").replace(/'/g, '"');
    } そうでない場合 (type !== "object") {
        結果 = データとします。

        //data は基本データ型である可能性があるので、ここで処理します if (Number.isNaN(data) || data === Infinity) {
            //NaN および Infinity のシリアル化は「null」を返します
            結果 = "null";
        } そうでない場合 (isUndefined(データ) || isSymbol(データ) || isFunction(データ)) {
            // 関数のシリアル化は undefined を返すため、undefined およびシンボル return undefined と一緒に処理されます。
        } そうでない場合 (type === "文字列") {
            結果 = '"' + データ + '"';
        }

        String(結果)を返します。
    }
}