Beste Möglichkeit, den Schlüssel im JSON-Objekt zu ersetzen

JSON (JavaScript Object Notation, JS Object Notation) ist ein leichtes Datenaustauschformat. Es basiert auf einer Teilmenge von ECMAScript (js-Spezifikation, die von der European Computer Association entwickelt wurde) und verwendet ein von der Programmiersprache völlig unabhängiges Textformat zum Speichern und Darstellen von Daten. Die Einfachheit und klare hierarchische Struktur machen JSON zu einer idealen Datenaustauschsprache. Es ist für Menschen leicht zu lesen und zu schreiben und für Maschinen leicht zu analysieren und zu generieren und kann die Effizienz der Netzwerkübertragung effektiv verbessern.

Wenn Sie den Titel sehen, fragen Sie sich vielleicht: Ist es eine Untersuchung einer so einfachen Frage wert? Wenn ich ein JSON-Objekt habe, kann ich dies mit nur wenigen Codezeilen tun:

var obj = {
    "_id": "5078c3a803ff4197dc81fbfb",
    "E-Mail": "[email protected]",
    "Bild": "eine_Bild-URL",
    "name": "Name 1"
};

var neuer_Schlüssel = "id";
var alter_Schlüssel = "_id";

obj[neuer_Schlüssel] = obj[alter_Schlüssel];
lösche obj[alter_Schlüssel];

Ja, das stimmt! Der obige Code erledigt die Aufgabe einwandfrei und ersetzt "_id" durch "id" im Obj-Objekt.

In den meisten Fällen verursacht dieser Ansatz keine Probleme. Wenn Sie jedoch das Obj-Objekt in ein Dokument serialisieren und die Unterschiede vergleichen müssen, treten Probleme auf.

// Ändere das vorherige Objekt
{
    "_id": "5078c3a803ff4197dc81fbfb",
    "E-Mail": "[email protected]",
    "Bild": "eine_Bild-URL",
    "name": "Name 1"
}

// Objekt nach der Änderung 
// JSON.stringify(obj, null, "\t")
{
    "E-Mail": "[email protected]",
    "Bild": "eine_Bild-URL",
    "name": "Name 1",
    "id": "5078c3a803ff4197dc81fbfb"
}

Der neu hinzugefügte Schlüssel wird standardmäßig am Ende platziert und da wir den vorherigen Schlüssel während des Ersetzungsprozesses gelöscht haben, unterscheidet sich das Objekt nach der Serialisierung erheblich vom vorherigen Objekt.

Wie können wir also sicherstellen, dass der Schlüsselaustausch mit minimalen Unterschieden erfolgt? Hier sind einige Methoden, die ich gefunden habe:

Object.prototype.renameProperty = Funktion (alterName, neuerName) {
     // Nichts tun, wenn die Namen gleich sind
     wenn (alterName === neuerName) {
         gib dies zurück;
     }
    // Überprüfen Sie den alten Eigenschaftsnamen, um einen ReferenceError im strikten Modus zu vermeiden.
    wenn (diese.hasOwnProperty(alterName)) {
        dieser[neuerName] = dieser[alterName];
        lösche diesen [alten Namen];
    }
    gib dies zurück;
};

Funktion renameKeys(obj, newKeys) {
  const keyValues ​​​​= Object.keys(obj).map(key => {
    const neuerSchlüssel = neueSchlüssel[Schlüssel] || Schlüssel;
    return { [neuerSchlüssel]: obj[Schlüssel] };
  });
  return Object.assign({}, ...Schlüsselwerte);
}


const obj = { a: "1", b: "2" };
const neueKeys = { a: "A", c: "C" };
const renamedObj = renameKeys(obj, neueSchlüssel);
console.log(umbenanntes Objekt);
// {A:"1", b:"2"}

// Verwenden der Funktion _.mapKeys() von lodash var user = {
  Name: "Andrew",
  Ich würde: 25,
  gemeldet: falsch
};

var umbenannt = _.mapKeys(Benutzer, Funktion(Wert, Schlüssel) {
  Eingabetaste + "_" + Benutzer-ID;
});

console.log (umbenannt);

var str = JSON.stringify(Objekt);
str = str.replace(/alterSchlüssel/g, 'neuerSchlüssel');
str = str.replace(/alterSchlüssel2/g, 'neuerSchlüssel2');

Objekt = JSON.parse(str);

Funktion umbenennenObjektSchlüssel(altesObjekt, alterName, neuerName) {
    const neuesObj = {};

    Objekt.Schlüssel(altesObjekt).fürJeden(Schlüssel => {
        const-Wert = altesObj[Schlüssel];

        if (Schlüssel === alterName) {
            neuesObj[neuerName] = Wert;
        } anders {
            newObj[Schlüssel] = Wert;
        }
    });

    gib neuesObjekt zurück;
}

Daten = {Schlüssel1: "Wert1", Schlüssel2: "Wert2", Schlüssel3: "Wert3"}; 

keyMap = {key1: "erster Schlüssel", key2: "zweiter Schlüssel", key3: "dritter Schlüssel"};

mappedData = Objekt.keys(keyMap).reduce((obj,k) => Objekt.assign(obj, { [keyMap[k]]: data[k] }),{});

Konsole.log(zugeordneteDaten);

Einige der oben genannten Beispiele können unsere Anforderungen erfüllen, und einige davon sind im Wesentlichen gleichwertig mit dem Code am Anfang dieses Artikels (mit nur geringfügigen Unterschieden in der Ausführungseffizienz). Doch alle diese Beispiele erfüllen ausnahmslos die folgenden beiden Anforderungen nicht gleichzeitig:

Behalten Sie die Reihenfolge der zu ersetzenden Schlüssel im ursprünglichen JSON-Objekt bei. Dadurch wird sichergestellt, dass die Reihenfolge der Schlüssel in der Zeichenfolgenausgabe nach der Ausführung von JSON.stringify() mit dem ursprünglichen JSON-Objekt übereinstimmt. Ändern Sie das ursprüngliche JSON-Objekt, anstatt ein neues JSON-Objekt zurückzugeben. In einigen Fällen müssen wir die Unterelemente eines komplexen JSON-Objekts ändern. Wenn nach der Änderung ein neues JSON-Objekt zurückgegeben wird, besteht keine Garantie, dass das neue Objekt im ursprünglichen JSON-Objekt widergespiegelt wird. Beispielsweise ist jspath eine JavaScript-Bibliothek, die untergeordnete Elemente in einem gegebenen JSON-Objekt über eine domänenspezifische Sprache (DSL) finden kann. Mit dem folgenden Code können wir problemlos die Elemente in der Automobileigenschaft des Obj-Objekts finden, bei denen Hersteller === „Honda“ und Jahr > 2009 ist.

var obj = {
    "Automobile" : [
        { "Hersteller" : "Nissan", "Modell" : "Teana", "Jahr" : 2011 },
        { "Hersteller" : "Honda", "Modell" : "Jazz", "Jahr" : 2010 },
        { "Hersteller" : "Honda", "Modell" : "Civic", "Jahr" : 2007 },
        { "Hersteller" : "Toyota", "Modell" : "Yaris", "Jahr" : 2008 },
        { "Hersteller" : "Honda", "Modell" : "Accord", "Jahr" : 2011 }
    ],
    "Motorräder" : [{ "Hersteller" : "Honda", "Modell" : "ST1300", "Jahr" : 2012 }]
};

var res = JSPath.apply('.automobiles{.maker === "Honda" && .year > 2009}', obj);

// res: [{ "Hersteller" : "Honda", "Modell" : "Jazz", "Jahr" : 2010 }, { "Hersteller" : "Honda", "Modell" : "Accord", "Jahr" : 2011 }]

Beachten Sie, dass das hier zurückgegebene Res-Objekt Teil des Obj-Objekts ist. Dies bedeutet, dass alle nachfolgenden Änderungen am Res-Objekt im Obj-Objekt widergespiegelt werden. Wenn wir einige Schlüssel in res ersetzen und ein neues JSON-Objekt zurückgeben, wird diese Änderung nicht im Obj-Objekt widergespiegelt.

Grundidee: Da der neu hinzugefügte Schlüssel standardmäßig an letzter Stelle steht, durchlaufen Sie einfach alle Schlüssel des JSON-Objekts, ersetzen Sie die Schlüssel nacheinander durch einen temporären Namen und ersetzen Sie anschließend den temporären Namen wieder zurück. Wird bei diesem Vorgang ein Schlüssel gefunden, der tatsächlich ersetzt werden muss, erfolgt kein zweiter Austausch. Hier ist der spezifische Code:

var obj = {
    "_id": "5078c3a803ff4197dc81fbfb",
    "E-Mail": "[email protected]",
    "Bild": "eine_Bild-URL",
    "name": "Name 1"
};

var neuer_Schlüssel = "id";
var alter_Schlüssel = "_id";

Objekt.Schlüssel(Objekt).fürJeden(Schlüssel => {
    wenn (Schlüssel === alter Schlüssel) {
        obj[neuer_Schlüssel] = obj[Schlüssel];
        lösche Objekt[Schlüssel];
    } anders {
        obj[`_${key}`] = obj[Schlüssel];
        lösche Objekt[Schlüssel];

        obj[`${key}`] = obj[`_${key}`];
        lösche Objekt[`_${key}`];
    }
});

Der endgültige Effekt ist wie folgt:

Wenn Sie Universalität berücksichtigen, müssen Sie das angegebene JSON-Objekt möglicherweise rekursiv durchlaufen. Der obige Code gibt nur eine Idee. In Anbetracht der Ausführungseffizienz und Sicherheit ist dies nicht die beste Lösung. Wir können es im tatsächlichen Gebrauch schrittweise verbessern.

Oben finden Sie die Details der besten Lösung zum Ersetzen des Schlüssels im JSON-Objekt. Weitere Informationen zum Ersetzen des Schlüssels im JSON-Objekt finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!