Frage Wie entferne ich eine Eigenschaft von einem JavaScript-Objekt?


Angenommen, ich erstelle ein Objekt wie folgt:

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

Was ist der beste Weg, um die Eigenschaft zu entfernen regex mit neuen enden myObject wie folgt?

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

4893
2017-10-16 10:57


Ursprung


Antworten:


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 lesen möchten, Stack Overflow Benutzer Kangax hat einen unglaublich ausführlichen Blogbeitrag über die delete Aussage auf ihrem Blog, Verständnis für das Löschen. Es ist sehr zu empfehlen.


6817
2017-10-16 10:58



Operator delete ist unerwartet langsam!

Schaue auf die Benchmark.

Delete ist die einzig wahre Methode, um die Eigenschaften eines Objekts ohne irgendwelche Reste zu entfernen, aber es funktioniert ~ 100 mal langsamer, im Vergleich zu seiner "Alternative", Einstellung object[key] = undefined.

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

Wann sollte man verwenden? delete und wenn der Wert auf undefined ?

Ein Objekt kann als eine Gruppe von Schlüssel / Wert-Paaren angesehen werden. Was ich einen 'Wert' nenne, ist ein Primitiv oder ein Verweis auf ein anderes Objekt, das mit diesem 'Schlüssel' verbunden ist.

Benutzen delete, wenn Sie das Ergebnisobjekt an den Code übergeben, über den Sie keine Kontrolle haben (oder wenn Sie sich bezüglich Ihres Teams oder Ihrer Person nicht sicher sind).

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

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

Einstellung verwenden auf undefined, wenn Sie sich um Leistung kümmern. Es kann Ihrem Code einen deutlichen Schub verleihen.

Das Schlüssel bleibt auf seinem Platz in der Hashmap, nur der Wert wird durch ersetzt undefined. Verstehe das for..in Schleife wird immer noch über diesen Schlüssel iterieren.

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

Mit dieser Methode nicht alle Möglichkeiten zur Bestimmung der Existenz von Eigentum wird funktionieren wie erwartet.

Dieser Code lautet jedoch:

object.field === undefined

werden sich für beide Methoden gleich verhalten.

Tests

Um es zusammenzufassen, Differenzen sind alles über Möglichkeiten, die Eigenschaft Existenz zu bestimmen, und über for..in Schleife.

 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 Memory-Lecks!

Während dem Benutzen obj[prop] = undefined ist schneller als das tun delete obj[prop], eine andere wichtige Überlegung ist das obj[prop] = undefined ist möglicherweise nicht immer angemessen. delete obj[prop] entfernt prop von obj und löscht es aus der Erinnerung während obj[prop] = undefined setzt einfach den Wert von prop zu undefined was geht prop immer noch in Erinnerung. Wenn also viele Schlüssel erstellt und gelöscht werden, verwenden Sie obj[prop] = undefined kann einen kostspieligen Speicherabgleich erzwingen (was dazu führt, dass die Seite einfriert) und möglicherweise einen Fehler wegen zu wenig Arbeitsspeicher hat. 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 );
});

Im obigen Code einfach nodeRecords[i][lastTime] = undefined; führt zu einem massiven Speicherverlust durch jeden Animationsrahmen. Jedes Frame, alle 65536-DOM-Elemente nehmen weitere 65536 einzelne Slots auf, aber die vorherigen 65536-Slots werden nur auf undefiniert gesetzt, wodurch sie im Speicher hängen bleiben. Mach weiter, versuche den obigen Code in der Konsole auszuführen und sieh selbst. Nachdem Sie einen Fehler aufgrund unzureichenden Arbeitsspeichers erzwungen haben, versuchen Sie, ihn erneut auszuführen, außer mit der folgenden Version des Codes, der den Fehlercode verwendet deleteOperator stattdessen.

"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 Codefragment zu sehen ist, gibt es einige seltene geeignete Anwendungsfälle für die delete Operator. Mach dir jedoch keine Sorgen um dieses Problem. Dies wird nur ein Problem mit Objekten mit langer Lebensdauer, die ständig neue Schlüssel hinzufügen. In jedem anderen Fall (in fast jedem Fall in der realen Welt Programmierung), ist es am besten zu verwenden obj[prop] = undefined. Der Hauptzweck dieses Abschnitts ist nur, um Sie darauf aufmerksam zu machen, so dass Sie in der seltenen Möglichkeit, dass dies zu einem Problem in Ihrem Code wird, das Problem leichter verstehen und somit nicht stundenlang Ihren Code sezieren müssen und verstehe dieses Problem.

Nicht immer festlegen undefined

Ein wichtiger Aspekt von Javascript ist der Polymorphismus. Polymorphismus ist, wenn Sie die gleiche Variable / Slot-in-einem-Objekt verschiedenen Typen zuweisen, wie unten gezeigt.

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

Es gibt jedoch zwei wichtige, nicht lösbare Probleme mit polymorphen Arrays:

  1. Sie sind langsam und ineffizient. Beim Zugriff auf einen bestimmten Index muss der Browser nicht nur den globalen Typ für das Array abrufen, sondern muss den Typ pro Index abrufen, 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 ein polymorphes Array so wiederherstellen, dass es nicht polymorph ist, wird es dennoch vom Browser als polymorphes Array gespeichert.

Man kann Polymorphismus mit einer Drogenabhängigkeit vergleichen. Auf den ersten Blick scheint es unglaublich lukrativ: schöner, flockiger Code. Dann führt der Codierer seine Anordnung zu dem Arzneimittel des Polymorphismus ein. Sofort wird das polymorphe Array weniger effizient und es kann niemals so effizient werden, wie es vorher war, seit es unter Drogen steht. Um solche Umstände mit dem wirklichen Leben zu korrelieren, könnte jemand, der Kokain konsumiert, nicht einmal in der Lage sein, einen einfachen Türgriff zu bedienen, geschweige denn in der Lage sein, Ziffern von PI zu berechnen. Gleichermaßen kann ein Array auf dem Arzneimittel des Polymorphismus niemals so effizient sein wie ein monomorphes Array.

Aber wie verhält sich eine Drogenreise - Analogie zur delete Betrieb? Die Antwort enthält die letzte Codezeile im obigen Snippet. Also lassen Sie es sich nochmal durchsehen, 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] = "" polemorphism nicht, während bar[1] = undefined tut. Daher sollte man, wann immer möglich, den entsprechenden Typ für ihre Objekte verwenden, um nicht versehentlich einen Polymorphismus zu verursachen. Eine solche Person kann die folgende Liste als allgemeine Referenz verwenden, um sie in Gang zu bringen. Bitte verwenden Sie die folgenden Ideen jedoch nicht explizit. Verwenden Sie stattdessen alles, was gut für Ihren Code funktioniert.

  • Wenn Sie ein Array / eine Variable verwenden, die dem booleschen Primitiv zugewiesen ist, verwenden Sie entweder false oder undefined als leerer Wert. Es ist zwar gut, unnötige Polymorphismen zu vermeiden, aber Ihren gesamten Code neu zu schreiben, um dies ausdrücklich zu verbieten. Dies führt wahrscheinlich zu einer Leistungsminderung. Nutze allgemeines Urteilsvermögen!
  • Verwenden Sie bei Verwendung eines Arrays / einer Variablen, die in das Nummernprimitiv eingegeben wurde 0 als leerer Wert. Beachten Sie, dass es intern zwei Arten von Zahlen gibt: schnelle ganze Zahlen (2147483647 bis einschließlich -2147483648) und langsame Fließkomma-Doubles (alles andere als einschließlich NaN und Infinity). Wenn eine ganze Zahl zu einem Double degro- miert wird, kann sie nicht wieder in eine ganze Zahl hochgestuft werden.
  • Verwenden Sie bei Verwendung eines Arrays / einer Variablen, die bzw. das in das Zeichenfolgengrundelement eingegeben wurde "" als leerer Wert.
  • Wenn Sie ein Symbol verwenden, warten Sie, warum verwenden Sie ein Symbol?!?! Symbole sind schlechte Juju für die Leistung. Alles, was für die Verwendung von Symbolen programmiert wurde, kann so umprogrammiert werden, dass keine Symbole mehr verwendet werden, was zu einem schnelleren Code ohne Symbole führt. Symbole sind wirklich nur super ineffiziente Meta-Zucker.
  • Wenn Sie etwas anderes verwenden, verwenden Sie null.

Achte jedoch darauf! Fange nicht plötzlich damit an, deinen gesamten bereits existierenden Code zu verwenden, da dies wahrscheinlich den bereits existierenden Code durchbrechen und / oder seltsame Fehler einführen würde. Vielmehr muss eine solche effiziente Vorgehensweise von Anfang an implementiert werden, und bei der Konvertierung von bereits vorhandenem Code wird empfohlen, alle Zeilen, die sich darauf beziehen, zu verdoppeln, zu verdreifachen, zu vervierfachen, um zu versuchen, alten Code auf diese neue Praxis zu aktualisieren riskant wie es lohnend ist.


700
2018-02-12 17:48



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.


192
2017-10-16 11:03



Aktualisierung 2018-07-21: Ich habe mich lange Zeit über diese Antwort geschämt, daher denke ich, dass es an der Zeit ist, dass ich etwas nachbessere. Nur ein kleiner Kommentar, Klarstellung und Formatierung, um das Lesen der unnötigen langen und verschlungenen Teile dieser Antwort zu beschleunigen.


DIE KURZE VERSION

Die eigentliche Antwort auf die Frage

Wie andere gesagt haben, können Sie verwenden delete.

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

Array-Äquivalent

Nicht delete aus einem Array. Benutzen Array.prototype.splice stattdessen.

arr // [1,2,3,4,5]
arr.splice(3,1); // 4
arr // [1,2,3,5]

DIE LANGE VERSION

JavaScript ist eine OOP-Sprache, also ist alles ein Objekt, einschließlich Arrays. Daher halte ich es für notwendig, auf einen bestimmten Vorbehalt hinzuweisen.

In Arrays, im Gegensatz zu einfachen alten Objekten, verwenden delete hinterlässt Müll in Form von null, Erstellen eines "Lochs" in der Anordnung.

var array = [1, 2, 3, 4];
delete array[2];
/* Expected result --> [1, 2, 4]
 * Actual result   --> [1, 2, null, 4]
 */

Wie du siehst, delete funktioniert nicht immer wie erwartet. Der Wert wird überschrieben, der Speicher wird jedoch nicht neu zugewiesen. Das heißt, array[4] wird nicht nach umgezogen array[3]. Was ist im Gegensatz zu Array.prototype.unshift, das ein Element am Anfang des Arrays einfügt und alles verschiebt (array[0] wird array[1], etc.)

Ehrlich gesagt, abgesehen von der Einstellung zu null eher, als undefined- was recht seltsam ist - dieses Verhalten sollte nicht sei überraschend, da delete ist ein unärer Operator, wie typeof, das ist in die Sprache hart gekocht und soll sich nicht um das kümmern Art des Objekts, auf dem es verwendet wird, während Array ist eine Unterklasse von Object mit Methoden speziell für Arbeiten mit Arrays. Also gibt es keinen guten Grund dafür deleteeinen Spezialfall für das erneute Verschieben des Arrays eingebaut zu haben, da dies die Arbeit mit unnötiger Arbeit verlangsamen würde. Rückblickend waren meine Erwartungen unrealistisch.

Natürlich, es hat getan überrasch mich. Weil ich dies geschrieben habe, um meinen Kreuzzug gegen "null Müll" zu rechtfertigen:

Ignorieren der Gefahren und Probleme in nullund der Raumverschwendung kann dies problematisch sein, wenn das Array genau sein muss.

Was ist eine schreckliche Rechtfertigung für die Beseitigung der nulls--null ist nur gefährlich bei unsachgemäßer Verwendung und hat nichts mit "Präzision" zu tun. Der wahre Grund, warum Sie nicht sollten delete von einem Array ist, weil müllgefüllte und chaotische Datenstrukturen herum schlampig und fehleranfällig sind.

Was folgt, ist ein künstliches Szenario, das ziemlich langatmig wird, so dass Sie zum Abschnitt springen können, Die Lösung, wenn du willst. Der einzige Grund, warum ich diesen Abschnitt verlasse, ist, weil ich denke, dass einige Leute es für witzig halten und ich nicht "der Typ" sein will, der eine "lustige" Antwort postet und später alle "Lustigen" löscht .

... Es ist dumm, ich weiß.

Das konstruierte und langatmige PDP-11-Szenario

Angenommen, Sie erstellen eine Webanwendung, die JSON-Serialisierung verwendet, um ein Array zu speichern, das für "Tabs" in einer Zeichenfolge verwendet wird (in diesem Fall localStorage). Lassen Sie uns auch sagen, dass der Code die numerischen Indizes der Mitglieder des Arrays verwendet, um sie beim Zeichnen auf den Bildschirm zu "benennen". Warum machst du das, anstatt nur den "Titel" zu speichern? Weil... Gründe dafür.

Okay, lassen Sie uns nur sagen, dass Sie versuchen, Speicher auf die Bitte von diesem zu speichern ein Benutzer, der einen PDP-11-Minicomputer aus den 60er Jahren unter UNIX betreibt und seinen eigenen auf Elinks basierenden, JavaScript-konformen, zeilen-druckerfreundlichen Browser geschrieben hat, weil X11 ist Außer Frage.

Zunehmend dummes Randfall-Szenario beiseite, mit delete auf dem Array wird dazu führen null verschmutzen das Array und verursachen später wahrscheinlich Bugs in der App. Und wenn Sie nach etwas suchen nullEs würde direkt die Zahlen überspringen, die dazu führen, dass die Tabs gerendert werden [1] [2] [4] [5] ....

if (array[index] == null)
    continue;
else
    title = (index + 1).toString();
/* 0 -> "1"
 * 1 -> "2"
 * 2 -> (nothing)
 * 3 -> "4"
 */

Ja, das ist definitiv nicht das, was du wolltest.

Jetzt du könnte behalte einen zweiten Iterator, wie j, um nur zu inkrementieren, wenn gültige Werte aus dem Array gelesen werden. Aber das würde das nicht genau lösen null Problem, und Sie müssen immer noch bitte Troll PDP-11 Benutzer. Ach, sein Computer einfach nicht habe genug Speicher, um die letzte ganze Zahl zu halten (Frag nicht, wie er mit einem Array variabler Breite zurechtkommt ...).

Also schickt er dir eine wütende E-Mail:

Hey, your webapp broke my browser! I checked my localStorage database after your stupid code made my browser segfault, and this is what I found:

>"tabs:['Hello World', 'foo bar baz', null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, ... ]"

After clearing my precious data, it segfaulted again, and I did a backtrace, and what do I find? WHAT DO I FIND!? YOU USE TOO MANY VARIABLES!

>var i = index;
>var j = 1;

Grr, I am angry now.
-Troll Davidson

Jetzt bist du am Ende. Dieser Typ hat sich nonstop über deine App beschwert, und du willst ihm sagen, er soll den Mund halten und einen besseren Computer holen.

Die Lösung: Array.prototype.splice

Zum Glück, Arrays machen haben eine spezielle Methode zum Löschen von Indizes und zum Neuzuweisen von Speicher: Array.prototype.splice(). Du könntest so etwas schreiben:

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

Und genau so haben Sie Mr. PDP-11 gefreut. Hurra! (Ich würde ihm immer noch sagen, aber ...)

Array.prototype.splice vs Array.prototype.slice

Ich finde es wichtig, auf den Unterschied zwischen diesen beiden ähnlich benannten Funktionen hinzuweisen, da sie beide sehr nützlich sind.

Array.prototype.splice (Anfang, n)

.splice() Wandelt das Array um und gibt die entfernten Indizes zurück. Das Array wird ausgehend vom Index geschnitten, start, und n Elemente werden ausgeschnitten. Wenn n nicht spezifiziert ist, wird das gesamte Array nach start ist ausgeschnitten (n = array.length - start).

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

// a     [5,4,3,2,1]
// start  0 1 2 - -
// n      - - 1 2 -

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice (Anfang, Ende)

.slice() ist nicht-destruktiv und gibt ein neues Array mit den angegebenen Indizes aus start zu end. Ob end ist nicht angegeben, das Verhalten ist das gleiche wie .splice() (end = array.length). Das Verhalten ist ein bisschen schwierig, da aus irgendeinem Grund, end Indizes von 1 statt 0. Ich weiß nicht, warum es das tut, aber so ist es. Auch wenn end <= start, das Ergebnis ist ein leeres Array.

let a = [5,4,3,2,1];
let chunks = [
    a.slice(2,0),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ];

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

Das ist eigentlich nicht das, was passiert, aber es ist einfacher, so zu denken. Laut MDN, hier ist was passiert:

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

Der angegebene Index end wird einfach von der Scheibe ausgeschlossen. Die eingeklammerten Indizes geben an, was in Scheiben geschnitten wird. So oder so, das Verhalten ist nicht intuitiv und es ist verpflichtet, seinen fairen Anteil von Off-by-One-Fehler zu verursachen, so dass Sie es möglicherweise hilfreich finden, eine Wrapper-Funktion, um das Verhalten von besser zu emulieren .splice():

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

Beachten Sie, dass die Wrapper-Funktion sehr streng auf Typen ausgelegt ist und zurückgegeben wird null wenn irgendetwas aus ist. Dazu gehört das Einfügen einer Zeichenfolge wie "3". Es ist dem Programmierer überlassen, gewissenhaft mit seinen Typen umzugehen. Dies soll eine gute Programmierpraxis fördern.

Update bezüglich is_array()

Dies ist in Bezug auf dieses (jetzt entfernte) Snippet:

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

So wie es sich herausstellt, gibt es tatsächlich eine eingebaute Möglichkeit zu sagen, ob ein Array wirklich ein Array ist, und das ist Array.isArray(), eingeführt in ECMAScript 5 (Dezember 2009). Ich fand dies, während ich mich umsah, ob es eine Frage danach gab, Arrays von Objekten zu sagen, um zu sehen, ob es eine bessere Lösung als meine gab, oder um meine hinzuzufügen, wenn es keine gab. Wenn Sie also eine Version von JavaScript verwenden, die älter ist als ECMA 5, gibt es Ihr Polyfill. Ich empfehle jedoch dringend, meine is_array() Englisch: www.saferinternet.org/ww/en/pub/ins.../web_2_0.htm Die Tatsache, dass alte JavaScript - Versionen weiterhin unterstützt werden, bedeutet, die alten Browser, die sie implementieren, weiterhin zu unterstützen, was die Verwendung von unsicherer Software fördert und die Benutzer einem Risiko von Malware aussetzt. Also bitte, benutze es Array.isArray(). Benutzen let und const. Verwenden Sie die neuen Funktionen, die der Sprache hinzugefügt werden. Nicht Verwenden Sie Anbieterpräfixe. Löschen dass IE Polyfill Mist von Ihrer Website. Löschen Sie das XHTML <!CDATA[[... Mist auch - wir sind 2014 zu HTML5 gewechselt. Je früher jeder die Unterstützung für diese alten / esoterischen Browser zurückzieht, desto früher werden die Browser-Anbieter tatsächlich dem Web-Standard folgen und die neue Technologie annehmen, und desto schneller können wir weitermachen ein sichereres Web.


133
2017-09-18 00:56



Alte Frage, moderne Antwort. Unter Verwendung der Destrukturierung von Objekten, a ECMAScript 6 Funktion, es ist so einfach wie:

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

Oder mit dem Fragen-Beispiel:

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

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


Bearbeiten:

Um der gleichen Variablen erneut zuzuweisen, verwenden Sie a let:

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

91
2017-11-08 18:02



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

Beachten Sie, dass _.pick() und _.omit() beide geben eine Kopie des Objekts zurück und ändern das ursprüngliche Objekt nicht direkt. Das Zuweisen des Ergebnisses zum ursprünglichen Objekt sollte den Trick machen (nicht gezeigt).

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

Gibt eine Kopie des Objekts zurück, gefiltert, um nur Werte für das Objekt zu erhalten Whitelist-Schlüssel (oder Array von gültigen Schlüsseln).

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

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

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

Gibt eine Kopie des Objekts zurück, gefiltert, um das Objekt zu entfernen Blacklisted Keys (oder Array von Schlüsseln).

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

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

Für Arrays, _.filter() und _.reject() kann in ähnlicher Weise verwendet werden.


65
2018-05-24 18:53



Der Begriff, den Sie in Ihrem Fragetitel verwendet haben Remove a property from a JavaScript object, kann auf verschiedene Arten interpretiert werden. Die eine ist, sie für den gesamten Speicher und die Liste der Objektschlüssel zu entfernen, oder die andere ist nur, um sie von Ihrem Objekt zu entfernen. Wie es in einigen anderen Antworten erwähnt wurde, die delete Stichwort ist der Hauptteil. Nehmen wir an, Sie haben Ihr Objekt wie:

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

Wenn Sie tun:

console.log(Object.keys(myJSONObject));

das Ergebnis wäre:

["ircEvent", "method", "regex"]

Sie können diesen spezifischen Schlüssel aus Ihren Objektschlüsseln löschen, wie zum Beispiel:

delete myJSONObject["regex"];

Dann drücken Ihre Objekte mit Object.keys(myJSONObject) wäre:

["ircEvent", "method"]

Aber der Punkt ist, wenn Sie sich Gedanken über Speicher und Sie möchten, dass das Objekt vollständig aus dem Speicher entfernt wird, wird empfohlen, es auf Null festzulegen, bevor Sie den Schlüssel löschen:

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

Der andere wichtige Punkt hier ist, vorsichtig mit Ihren anderen Referenzen auf das gleiche Objekt zu sein. Zum Beispiel, wenn Sie eine Variable wie:

var regex = myJSONObject["regex"];

Oder fügen Sie es als neuen Zeiger auf ein anderes Objekt hinzu:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

Dann auch wenn Sie es von Ihrem Objekt entfernen myJSONObject, dieses spezifische Objekt wird nicht aus dem Speicher gelöscht, da der regex Variable und myOtherObject["regex"] habe immer noch ihre Werte. Wie könnten wir dann das Objekt aus dem Speicher entfernen?

Die Antwort wäre zu lösche alle Referenzen, die du in deinem Code hast, und deute auf genau dieses Objekt und auch nicht nutzen var Anweisungen zum Erstellen neuer Verweise auf dieses Objekt. Dieser letzte Punkt bezüglich var Aussagen, ist eines der wichtigsten Probleme, mit denen wir normalerweise konfrontiert sind, weil zu verwenden var Anweisungen verhindern, dass das erstellte Objekt entfernt wird.

Dies bedeutet, dass Sie in diesem Fall das Objekt nicht entfernen können, weil Sie das Objekt erstellt haben regex variabel über a var Aussage, und wenn Sie tun:

delete regex; //False

Das Ergebnis wäre false, was bedeutet, dass Ihre delete-Anweisung nicht wie erwartet ausgeführt wurde. Aber wenn Sie diese Variable zuvor nicht erstellt hätten und nur gehabt hätten myOtherObject["regex"] Als Ihre letzte existierende Referenz könnten Sie dies tun, indem Sie es entfernen:

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

Mit anderen Worten, ein JavaScript-Objekt wird gelöscht, sobald in Ihrem Code kein Verweis auf dieses Objekt mehr vorhanden ist.


Aktualisieren: Danke an @AgentME:

Das Festlegen einer Eigenschaft auf null vor dem Löschen wird nicht durchgeführt   alles (außer das Objekt wurde von Object.seal und dem   Löschen schlägt fehl. Das ist in der Regel nicht der Fall, es sei denn Sie speziell   Versuchen).

Um mehr Informationen zu erhalten Object.seal: Object.seal ()


33
2018-02-12 06:29