Implementierung einer vereinfachten Version von JSON.stringify und seine sechs Hauptfunktionen im Detail erklärt

const obj = {
    bol: neuer Boolean(true),
    num: neue Zahl(1),
    str: neuer String(1)
}

Typ von obj.bol; // Objekt
Typ von Objekt.Nummer; // Objekt
Typ von obj.str; // Objekt

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

const stringifyObj = JSON.parse(JSON.stringify(obj));
Typ von stringifyObj.bol; // Boolesch
typeof stringifyObj.num; // Zahl
Typ von stringifyObj.str; // Zeichenfolge

const obj = {
    nan: NaN,
    Unendlichkeit: Unendlichkeit,
    null: null,
};

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

const obj = {
    nan: NaN,
    Unendlichkeit: Unendlichkeit,
    null: null,
    zuJSON() {
        return "hat toJSON-Funktion";
    },
};

JSON.stringify(obj); // "hat eine toJSON-Funktion"

const obj = {
    Datum: neues Datum(),
};

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

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

JSON.stringify(obj); // {}

const fn = Funktion () {};
const obj = {
    [undefiniert]: undefiniert,
    [fn]: Funktion () {},
    [Symbol()]: Symbol()
};

JSON.stringify(obj); // {}

const arr = [undefiniert, Funktion fn() {}, Symbol()];

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

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

const obj = {
    Name: "Nordon",
    Alter: 18,
};

// Ändere das Alter in eine nicht aufzählbare Eigenschaft Object.defineProperty(obj, "age", {
    aufzählbar: falsch,
});

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

const obj = {
    Name: "Nordon",
    Alter: 18,
};

Konstante p = {
    Name: 'wy',
    obj
}

obj.p = p

JSON.stringify(obj);

const currying = (fn, ...outParams) => {
    // Anzahl der von der fn-Funktion benötigten Parameter abrufen const paramsLen = fn.length;

    return (...args) => {
        // Alle Parameter sammeln let params = [...outParams, ...args];
        // Wenn die Parameter die von fn geforderten Parameter nicht erreichen, mit dem Sammeln der Parameter fortfahren, if (params.length < paramsLen) {
            gibt Currying zurück (Fn, ... Parameter);
        }

        Funktion (...Parameter) zurückgeben;
    };
};

/**
 * Typ: Typ – [Objekt-Array], [Objektnummer] usw. * Quelle: Datenquelle */
const judgeType = (Typ, Quelle) => {
    gibt Object.prototype.toString.call(Quelle) === Typ zurück;
};

const isUndefined = currying(judgeType, "[Objekt undefiniert]");
const isSymbol = currying(judgeType, "[Objekt Symbol]");
const isFunction = currying(judgeType, "[Objektfunktion]");
const isObject = currying(judgeType, "[Objekt Objekt]");
const isNull = currying(judgeType, "[Objekt Null]");

Funktion jsonStringify(Daten) {
    let type = Datentyp;

    wenn (istNull(Daten)) { 
// null gibt direkt die Zeichenfolge „null“ zurück
        gibt "null" zurück;
    } sonst wenn (data.toJSON && Typ von data.toJSON === "Funktion") {
// Konfigurieren Sie die toJSON-Funktion, verwenden Sie direkt die von toJSON zurückgegebenen Daten und ignorieren Sie andere Daten return jsonStringify(data.toJSON());
    } sonst wenn (Array.isArray(data)) {
        lass Ergebnis = [];
        //Wenn es ein Array ist, kann jedes Element im Array von unterschiedlichem Typ sein data.forEach((item, index) => {
            wenn (istUndefined(Element) || istSymbol(Element) || istFunktion(Element)) {
                Ergebnis[Index] = "null";
            } anders {
                Ergebnis[index] = jsonStringify(Element);
            }
        });

        Ergebnis = "[" + Ergebnis + "]";

        Ergebnis zurückgeben.Ersetzen(/'/g, '"');
    } sonst wenn (istObjekt(Daten)) {
        //Verarbeitung gewöhnlicher Objekte let result = [];
        Objekt.Schlüssel(Daten).fürJedes((Element, Index) => {
            wenn (Typ des Elements !== "Symbol") {
                //Wenn der Schlüssel ein Symbolobjekt ist, ignorieren Sie if (
                    Daten[Element] !== undefiniert &&
                    Typ der Daten [Element] !== "Funktion" &&
                    Datentyp[Element] !== "Symbol"
                ) {
                    //Wenn der Schlüsselwert nicht definiert ist, eine Funktion oder ein Symbol ist, ignorieren Sie result.push(
                        '"' + Element + '"' + ":" + jsonStringify(Daten[Element])
                    );
                }
            }
        });

        return ("{" + result + "}").replace(/'/g, '"');
    } sonst wenn (Typ !== "Objekt") {
        lass Ergebnis = Daten;

        //Daten können ein grundlegender Datentyp sein, behandeln Sie ihn hier, wenn (Number.isNaN(data) || data === Infinity) {
            //NaN- und Infinity-Serialisierung gibt „null“ zurück
            Ergebnis = "null";
        } sonst wenn (istUndefined(Daten) || istSymbol(Daten) || istFunktion(Daten)) {
            // Da die Funktionsserialisierung „undefined“ zurückgibt, wird sie zusammen mit „undefined“ und dem Symbol „return undefined“ verarbeitet.
        } sonst wenn (Typ === "Zeichenfolge") {
            Ergebnis = '"' + Daten + '"';
        }

        returniere String(Ergebnis);
    }
}