variable - Wie entferne ich eine Eigenschaft aus einem JavaScript-Objekt?




javascript destroy object (20)

2 (ES6)

Für wen auch immer es nötig ist ...

Um die @ Koen-Antwort in diesem Thread zu vervollständigen, können Sie eine dynamische Variable mit der Spread-Syntax entfernen, indem Sie Folgendes tun:

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

* fooist eine neue Variable mit dem Wert von a(der 1 ist).


UPDATE :
Es gibt einige Möglichkeiten, eine Eigenschaft aus einem Objekt zu entfernen.
Jeder hat seine Vor- und Nachteile ( siehe Leistungsvergleich ):

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
löschen, lesbar und kurz, es ist jedoch möglicherweise nicht die beste Wahl, wenn Sie mit einer großen Anzahl von Objekten arbeiten, da die Leistung nicht optimiert wird.

delete obj[key];


Reassignment
Mehr als zweimal schneller alsdeletedie Eigenschaft, wird jedochnichtgelöscht und kann wiederholt werden.

obj[key] = null;
obj[key] = false;
obj[key] = undefined;


Spread-Operator Mit
diesemES6Operator können wir ein brandneues Objekt ohne Eigenschaften zurückgeben, ohne das vorhandene Objekt zu verändern. Der Nachteil ist, dass es die schlechtere Leistung hat und nicht empfohlen wird, wenn Sie viele Eigenschaften gleichzeitig entfernen möchten.

{ [key]: val, ...rest } = obj;

https://code.i-harness.com

Angenommen, ich erstelle ein Objekt wie folgt:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

Wie entferne myObject die Eigenschaftsausdehnung am besten, um mit myObject wie folgt myObject zu werden?

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};

Eigenschaftsentfernung in JavaScript

Es gibt viele verschiedene Optionen auf dieser Seite, nicht weil die meisten Optionen falsch sind - oder weil die Antworten Duplikate sind -, sondern weil die geeignete Technik von der Situation abhängt, in der Sie sich befinden, und den Zielen der Aufgaben, die Sie und / oder Sie stellen Team versucht zu erfüllen. Um Ihre Frage eindeutig zu beantworten, muss man wissen:

  1. Die Version von ECMAScript, auf die Sie abzielen
  2. Der Bereich der Objekttypen, für den Sie die Eigenschaften entfernen möchten, und der Typ der Eigenschaftsnamen, die Sie weglassen müssen (nur Strings? Symbole? Schwache Referenzen, die von beliebigen Objekten zugeordnet werden.) Dies sind seit Jahren Typen von Eigenschaftszeigern in JavaScript )
  3. Die Programmierethos / -muster, die Sie und Ihr Team verwenden. Bevorzugen Sie funktionale Ansätze und Mutationen sind in Ihrem Team verboten, oder wenden Sie objektorientierte Wild-West-Mutationstechniken an?
  4. Möchten Sie dies mit reinem JavaScript erreichen oder möchten Sie eine Drittanbieter-Bibliothek verwenden?

Sobald diese vier Fragen beantwortet wurden, gibt es im Wesentlichen vier Kategorien für das Entfernen von Eigenschaften in JavaScript, aus denen Sie auswählen können, um Ihre Ziele zu erreichen. Sie sind:

Löschen von mutativen Objekteigenschaften, unsicher

Diese Kategorie ist für die Bearbeitung von Objektliteralen oder Objektinstanzen gedacht, wenn Sie die ursprüngliche Referenz beibehalten oder weiterhin verwenden möchten und keine statusfreien Funktionsprinzipien in Ihrem Code verwenden. Ein Beispiel für eine Syntax in dieser Kategorie:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

Diese Kategorie ist die älteste, unkomplizierteste und am meisten unterstützte Kategorie der Entfernung von Immobilien. Es unterstützt Symbolzusätzlich zu Strings & Array-Indizes und funktioniert mit Ausnahme der ersten Version in jeder Version von JavaScript. Es ist jedoch mutativ, was einige Programmierprinzipien verletzt und Auswirkungen auf die Leistung hat. Es kann auch zu developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… erfassten Ausnahmen führen, wenn sie für developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .

Rest-basierte String-Eigenschaftsauslassung

Diese Kategorie ist für den Betrieb mit einfachen Objekt- oder Arrayinstanzen in neueren ECMAScript-Varianten vorgesehen, wenn ein nicht mutativer Ansatz gewünscht wird und Sie keine Symboltasten berücksichtigen müssen:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

Löschen mutativer Objekteigenschaften, sicher

Diese Kategorie ist für die Bearbeitung von Objektliteralen oder Objektinstanzen gedacht, wenn Sie die ursprüngliche Referenz beibehalten oder weiterhin verwenden möchten, während Sie verhindern, dass Ausnahmen für nicht konfigurierbare Eigenschaften ausgelöst werden:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

Während das Mutieren von Objekten an Ort und Stelle nicht zustandslos ist, können Sie die funktionale Natur von Reflect.deletePropertyPartial Application und andere funktionale Techniken verwenden, die mit deleteAnweisungen nicht möglich sind .

Syntaxbasierte Auslassung von String-Eigenschaften

Diese Kategorie ist für den Betrieb mit einfachen Objekt- oder Arrayinstanzen in neueren ECMAScript-Varianten vorgesehen, wenn ein nicht mutativer Ansatz gewünscht wird und Sie keine Symboltasten berücksichtigen müssen:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

Bibliotheksbasierte Auslassung von Eigenschaften

Diese Kategorie ermöglicht im Allgemeinen eine größere Funktionsflexibilität, einschließlich der Berücksichtigung von Symbolen und dem Weglassen mehrerer Eigenschaften in einer Anweisung:

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

Operator delete ist unerwartet langsam!

Schau dir die benchmark .

Löschen ist die einzig wahre Möglichkeit, Objekteigenschaften ohne Reste zu entfernen, aber sie arbeitet ~ 100 Mal langsamer als ihre "Alternative", wobei object[key] = undefined .

Diese Alternative ist nicht die richtige Antwort auf diese Frage! Wenn Sie es jedoch mit Vorsicht verwenden, können Sie einige Algorithmen drastisch beschleunigen. Wenn Sie delete in Schleifen verwenden und Probleme mit der Leistung haben, lesen Sie die ausführliche Erklärung.

Wann sollte man delete und wann den Wert auf undefined ?

Ein Objekt kann als ein Satz von Schlüsselwertpaaren angesehen werden. Was ich einen "Wert" nenne, ist ein Primitiv oder eine Referenz auf ein anderes Objekt, das mit diesem "Schlüssel" verbunden ist.

Verwenden Sie delete , wenn Sie das Ergebnisobjekt an den Code übergeben, auf den Sie keine Kontrolle haben (oder wenn Sie sich nicht sicher sind, ob Ihr Team oder Sie sich sicher sind).

Es löscht den Schlüssel aus der Hashmap .

 var obj = {
     field: 1     
 };
 delete obj.field;

Verwenden Sie die Einstellung zu undefined , wenn Sie Wert auf Leistung legen. Dies kann Ihren Code erheblich verbessern.

Der Schlüssel bleibt an seiner Stelle in der Hashmap , nur der Wert wird durch undefined . Verstehen Sie, dass die for..in Schleife diese Taste noch for..in .

 var obj = {
     field: 1     
 };
 obj.field = undefined;

Bei Verwendung dieser Methode funktionieren nicht alle Möglichkeiten zur Bestimmung der Existenz von Immobilien wie erwartet.

Dieser Code ist jedoch:

object.field === undefined

verhält sich für beide Methoden gleichwertig.

Tests

Zusammenfassend lässt sich for..in , dass es bei den Unterschieden alles um Wege geht, um die Existenz der Eigenschaft zu bestimmen, und etwa for..in Schleife in.

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

Vorsicht vor Speicherlecks!

Während die Verwendung von obj[prop] = undefined schneller ist als das delete obj[prop] , ist eine weitere wichtige Überlegung, dass obj[prop] = undefined nicht immer angemessen ist. delete obj[prop] entfernt die prop aus obj und löscht sie aus dem Gedächtnis, während bei obj[prop] = undefined der Wert von prop einfach auf undefined wodurch die prop noch in Erinnerung bleibt. Unter Umständen, in denen viele Schlüssel erstellt und gelöscht werden, kann die Verwendung von obj[prop] = undefined eine kostspielige Speicherabstimmung (das Einfrieren der Seite) und möglicherweise einen Speicherfehler verursachen. Untersuchen Sie den folgenden Code.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

In dem obigen Code einfach nodeRecords[i][lastTime] = undefined; verursacht einen massiven Speicherverlust, da jeder Animationsframe In jedem Frame werden alle 65536 DOM-Elemente um weitere 65536 einzelne Slots belegt. Die vorherigen 65536-Slots werden jedoch nur auf undefiniert gesetzt, sodass sie im Speicher bleiben. Versuchen Sie, den obigen Code in der Konsole auszuführen, und überzeugen Sie sich selbst. Versuchen Sie nach dem Erzwingen eines Out-of-Memory-Fehlers, diesen erneut auszuführen, außer mit der folgenden Version des Codes, der stattdessen den delete verwendet.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

Wie im obigen Code-Snippet zu sehen, gibt es einige selten geeignete Anwendungsfälle für den delete . Sorgen Sie sich jedoch nicht zu sehr um dieses Problem. Dies wird nur bei Objekten mit langer Lebensdauer zu einem Problem, bei denen ständig neue Schlüssel hinzugefügt werden. In jedem anderen Fall (was in der realen Programmierung fast immer der Fall ist), ist es am besten, obj[prop] = undefined . Der Hauptzweck dieses Abschnitts besteht darin, Sie darauf aufmerksam zu machen, so dass Sie in der seltenen Gelegenheit, dass dies zu einem Problem in Ihrem Code wird, das Problem leichter verstehen können und somit keine Stunden damit verbringen müssen, Ihren Code zu lokalisieren und verstehen dieses Problem.

Nicht immer auf undefined

Ein wichtiger Aspekt von Javascript ist der Polymorphismus. Polymorphismus ist, wenn verschiedene Variablen / Slot-in-An-Objekte zugewiesen werden, wie im Folgenden dargestellt.

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

Bei polymorphen Arrays gibt es jedoch zwei große, nicht zu lösende Probleme:

  1. Sie sind langsam und das Gedächtnis ineffizient. Beim Zugriff auf einen bestimmten Index muss der Browser nicht nur den globalen Typ für das Array abrufen, sondern den Typ auf Indexbasis, wobei jeder Index die zusätzlichen Metadaten seines Typs speichert.
  2. Einmal polymorph, immer polymorph. Wenn ein Array polymorph gemacht wird, kann der Polymorphismus in Webkit-Browsern nicht rückgängig gemacht werden. Selbst wenn Sie also ein polymorphes Array als nicht-polymorph anzeigen, wird es vom Browser immer noch als polymorphes Array gespeichert.

Man kann Polymorphismus mit einer Drogensucht vergleichen. Auf den ersten Blick erscheint es unglaublich lukrativ: schöner, flockiger Code. Dann führt der Kodierer sein Array in das Medikament des Polymorphismus ein. Sofort wird das polymorphe Array weniger effizient und kann nie so effizient werden wie zuvor, da es mit Drogen behandelt wird. Um einen solchen Umstand mit dem wirklichen Leben in Beziehung zu setzen, könnte jemand, der Kokain konsumiert, möglicherweise nicht einmal einen einfachen Türgriff betätigen, geschweige denn die PI-Ziffern berechnen. Ebenso kann ein Array auf dem Wirkstoff Polymorphismus niemals so effizient sein wie ein monomorphes Array.

Aber wie verhält sich eine Analogie zur Drogenreise mit der delete ? Die Antwort übernimmt die letzte Codezeile in dem obigen Snippet. Lassen Sie es also noch einmal prüfen, diesmal mit einer Wendung.

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

Beobachten. bar[1] = "" erzwingt keinen Polymorphismus, während bar[1] = undefined ist. Daher sollte man immer, wenn möglich, den entsprechenden Typ für ihre Objekte verwenden, um nicht versehentlich Polymorphismus zu verursachen. Eine solche Person kann die folgende Liste als allgemeine Referenz verwenden, um sie in Gang zu setzen. Bitte verwenden Sie die nachstehenden Ideen jedoch nicht explizit. Verwenden Sie stattdessen das, was für Ihren Code gut geeignet ist.

  • Wenn Sie ein Array / eine Variable verwenden, die für das boolesche Grundelement typisiert ist, verwenden Sie entweder false oder undefined als leeren Wert. Das Vermeiden von unnötigem Polymorphismus ist zwar gut, aber das erneute Schreiben des gesamten Codes, um explizit zu verbieten, führt wahrscheinlich zu einem Leistungsabfall. Verwenden Sie ein gemeinsames Urteil!
  • Wenn Sie ein Array / eine Variable verwenden, die für das Zahlenprimitiv eingegeben wurde, verwenden Sie 0 als leeren Wert. Beachten Sie, dass es intern zwei Arten von Zahlen gibt: schnelle Ganzzahlen (einschließlich 2147483647 bis einschließlich -2147483648) und langsame Fließkomma-Doubles (andere Werte als die von NaN und Infinity ). Wenn eine Ganzzahl zu einem Double herabgestuft wird, kann sie nicht zu einer Ganzzahl zurückgestuft werden.
  • Wenn Sie ein Array / eine Variable verwenden, die für das String-Grundelement typisiert ist, verwenden Sie "" als leeren Wert.
  • Wenn Sie ein Symbol verwenden, warten Sie, warum verwenden Sie ein Symbol?!?! Symbole sind schlechte Juju für Leistung. Alles, das für die Verwendung von Symbolen programmiert wurde, kann neu programmiert werden, um keine Symbole zu verwenden. Dies führt zu einem schnelleren Code ohne Symbole. Symbole sind wirklich nur super ineffizienter Metazucker.
  • Wenn Sie etwas anderes verwenden, verwenden Sie null .

Seien Sie jedoch vorsichtig! Fangen Sie jetzt nicht plötzlich mit Ihrem gesamten vorhandenen Code an, da dieser Code möglicherweise beschädigt wird und / oder seltsame Fehler auftreten. Vielmehr muss eine solche effiziente Vorgehensweise von Anfang an implementiert werden. Beim Konvertieren von bereits vorhandenem Code wird empfohlen, dass Sie alle Zeilen, die sich darauf beziehen, doppelt, dreifach und vierfach prüfen, da der Versuch unternommen werden kann, alten Code auf diese neue Vorgehensweise umzustellen riskant wie es lohnend ist.


Alte Frage, moderne Antwort. Mit der Objektdestrukturierung, einer ECMAScript 6 Funktion, ist es so einfach wie ECMAScript 6 :

const { a, ...rest } = { a: 1, b: 2, c: 3 };

Oder mit dem Fragenmuster:

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

Sie können es in Aktion im Babel-Testeditor sehen.

Bearbeiten:

Um derselben Variablen erneut zuzuweisen, verwenden Sie ein let :

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

Eine andere Alternative ist die Verwendung der Underscore.js- Bibliothek.

Beachten Sie, dass _.pick() und _.omit() beide eine Kopie des Objekts zurückgeben und das ursprüngliche Objekt nicht direkt ändern. Das Zuweisen des Ergebnisses zu dem ursprünglichen Objekt sollte den Trick ausführen (nicht gezeigt).

Referenz: link _.pick (Objekt, * Schlüssel)

Gibt eine Kopie des Objekts zurück, die so gefiltert ist, dass sie nur Werte für die auf der Whitelist aufgeführten Schlüssel (oder das Array gültiger Schlüssel) enthält.

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Referenz: link _.omit (Objekt, * Schlüssel)

Gibt eine Kopie des Objekts zurück, gefiltert, um die auf der schwarzen Liste aufgelisteten Schlüssel (oder das Array von Schlüsseln) wegzulassen.

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Für Arrays können _.filter() und _.reject() auf ähnliche Weise verwendet werden.


So was:

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

Demo

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
delete myObject.regex;

console.log(myObject);

Für alle, die mehr darüber kangax hat der Benutzer von einen unglaublich ausführlichen Blogbeitrag über die kangax in seinem Blog geschrieben: " Verstehen löschen" . Es wird dringend empfohlen.


Angenommen, Sie haben ein Objekt, das folgendermaßen aussieht:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

Löschen einer Objekteigenschaft

Wenn Sie das gesamte staffArray verwenden möchten, können Sie dies folgendermaßen tun:

delete Hogwarts.staff;

Alternativ können Sie auch Folgendes tun:

delete Hogwarts['staff'];

Auf ähnliche Weise würde das Entfernen des gesamten Schüler-Arrays durch Aufrufen von delete Hogwarts.students;oder erfolgendelete Hogwarts['students']; .

Löschen eines Array-Indexes

Wenn Sie nun einen einzelnen Mitarbeiter oder Studenten entfernen möchten, ist die Vorgehensweise etwas anders, da beide Eigenschaften selbst Arrays sind.

Wenn Sie den Index Ihres Mitarbeiters kennen, können Sie dies einfach tun:

Hogwarts.staff.splice(3, 1);

Wenn Sie den Index nicht kennen, müssen Sie auch eine Indexsuche durchführen:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

Hinweis

Während Sie technisch deletefür ein Array verwendet werden können, führt die Verwendung dieses Arrays zu falschen Ergebnissen, wenn Sie zum Beispiel Hogwarts.staff.lengthspäter aufrufen . Mit anderen Worten, deletedas Element wird entfernt, aber der Wert der lengthEigenschaft wird nicht aktualisiert . Die Verwendung deletewürde auch die Indizierung durcheinander bringen.

Wenn Sie also Werte aus einem Objekt löschen, müssen Sie immer zuerst prüfen, ob Sie mit Objekteigenschaften oder mit Arraywerten arbeiten, und dann die entsprechende Strategie wählen.

Wenn Sie damit experimentieren möchten, können Sie diese Geige als Ausgangspunkt verwenden.


Dieser Beitrag ist sehr alt und ich finde ihn sehr hilfreich, deshalb habe ich beschlossen, die von mir geschriebene unset-Funktion zu teilen, falls jemand anderes diesen Beitrag sieht und denkt, warum er nicht so einfach ist wie in PHP-unset-Funktion.

Der Grund für das Schreiben dieser neuen unsetFunktion besteht darin, den Index aller anderen Variablen in dieser hash_map beizubehalten. Sehen Sie sich das folgende Beispiel an und sehen Sie, wie sich der Index von "test2" nach dem Entfernen eines Werts aus der Hash_map nicht geändert hat.

function unset(unsetKey, unsetArr, resort){
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if(resort){
    j = -1;
  }
  for(i in tempArr){
    if(typeof(tempArr[i]) !== 'undefined'){
      if(resort){
        j++;
      }else{
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test','deletedString','test2'];

console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}

Hallo, du kannst diese einfache Art ausprobieren

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

Lodash benutzen

import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');

Ramda verwenden

R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}

Sehr einfach:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

delete myObject.regex;

Versuche dies

delete myObject['key'];

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined

Dies funktioniert in Firefox und Internet Explorer, und ich denke, es funktioniert in allen anderen.


const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

const { regex, ...other } = myObject;

console.log(myObject)
console.log(regex)
console.log(other)



Die Delete- Methode ist der beste Weg, um dies zu tun. Gemäß der MDN-Beschreibung entfernt der Delete-Operator eine Eigenschaft aus einem Objekt. Sie können also einfach schreiben:

delete myObject.regex;
// OR
delete myObject['regex'];

Der delete-Operator entfernt eine bestimmte Eigenschaft aus einem Objekt. Bei erfolgreicher Löschung wird true zurückgegeben, andernfalls wird false zurückgegeben. Es ist jedoch wichtig, die folgenden Szenarien zu berücksichtigen:

  • Wenn die Eigenschaft, die Sie löschen möchten, nicht vorhanden ist, hat delete keine Auswirkungen und gibt true zurück

  • Wenn eine Eigenschaft mit demselben Namen in der Prototypkette des Objekts vorhanden ist, verwendet das Objekt nach dem Löschen die Eigenschaft aus der Prototypkette (dh, Löschen hat nur Auswirkungen auf die eigenen Eigenschaften).

  • Mit var deklarierte Eigenschaften können nicht aus dem globalen Bereich oder aus dem Funktionsbereich einer Funktion gelöscht werden.

  • Delete kann daher keine Funktionen im globalen Bereich löschen (unabhängig davon, ob dies Teil einer Funktionsdefinition oder einer Funktion (Ausdruck) ist.

  • Funktionen, die Teil eines Objekts sind (abgesehen vom
    globalen Gültigkeitsbereich), können mit delete gelöscht werden.

  • Mit let oder const deklarierte Eigenschaften können nicht aus dem Bereich gelöscht werden, in dem sie definiert wurden. Nicht konfigurierbare Eigenschaften können nicht entfernt werden. Dazu gehören Eigenschaften von integrierten Objekten wie Math, Array, Object und Eigenschaften, die mit Methoden wie Object.defineProperty () als nicht konfigurierbar erstellt werden.

Der folgende Ausschnitt zeigt ein weiteres einfaches Beispiel:

var Employee = {
      age: 28,
      name: 'abc',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

Weitere Informationen und weitere Beispiele finden Sie unter dem folgenden Link:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…


Eine andere Lösung mit Array#reduce.

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

Es wird jedoch das ursprüngliche Objekt mutieren . Wenn Sie ein neues Objekt ohne den angegebenen Schlüssel erstellen möchten , weisen Sie die Reduktionsfunktion einfach einer neuen Variablen zu, zB:

(ES6)

const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);


Erstellen Sie ein neues Objekt ohne die "regex"Eigenschaft, da das Originalobjekt immer von anderen Programmteilen referenziert werden kann. Daher sollten Sie es vermeiden, es zu manipulieren.

const myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

const { regex, ...newMyObject } = myObject;

console.log(newMyObject);


Mit ramda#dissoc Sie ein neues Objekt ohne das Attribut regex:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

Sie können auch andere Funktionen verwenden, um denselben Effekt zu erzielen - Auslassen, Auswählen, ...


Sie können einfach jede Eigenschaft eines Objekts mit dem deleteSchlüsselwort löschen .

Zum Beispiel:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

Um beispielsweise eine Eigenschaft zu entfernen key1, verwenden Sie das deleteSchlüsselwort wie folgt:

delete obj.key1

Oder Sie können auch eine Array-ähnliche Notation verwenden:

delete obj[key1]

Ref: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .







object-properties