Angenommen, ich habe diesen Code:

var myArray = new Object();
myArray["firstname"] = "Bob";
myArray["lastname"] = "Smith";
myArray["age"] = 25;

Wenn ich nun "Nachname" entfernen wollte? .... gibt es ein Äquivalent von
myArray["lastname"].remove()?

(Ich brauche das Element weg, weil die Anzahl der Elemente wichtig ist und ich die Dinge sauber halten möchte.)

Objekte in JavaScript können als assoziative Arrays betrachtet werden, die Schlüssel (Eigenschaften) Werten zuordnen.

Um eine Eigenschaft aus einem Objekt in JavaScript zu entfernen, verwenden Sie den deleteOperator:

const o = { lastName: 'foo' }
o.hasOwnProperty('lastName') // true
delete o['lastName']
o.hasOwnProperty('lastName') // false

Beachten Sie, dass Sie beim deleteAnwenden auf eine Indexeigenschaft von ein dünn besiedeltes ArrayArray erstellen (dh ein Array mit einem fehlenden Index).

Wenn Sie mit Instanzen von arbeiten Arrayund kein dünn besiedeltes Array erstellen möchten - und dies normalerweise nicht -, sollten Sie Array#spliceoder verwenden Array#pop.

Beachten Sie, dass der deleteOperator in JavaScript den Speicher nicht direkt freigibt. Der Zweck besteht darin, Eigenschaften von Objekten zu entfernen. Wenn eine zu löschende Eigenschaft den einzigen verbleibenden Verweis auf ein Objekt enthält o, owird der Müll anschließend auf normale Weise gesammelt.

Die Verwendung von deleteOperator kann JavaScript - Engine die Fähigkeit beeinflussen optimize Code .

Alle Objekte in JavaScript werden als Hashtabellen / assoziative Arrays implementiert. Das Folgende ist also das Äquivalent:

alert(myObj["SomeProperty"]);
alert(myObj.SomeProperty);

Und wie bereits erwähnt, "entfernen" Sie eine Eigenschaft aus einem Objekt über das deleteSchlüsselwort, das Sie auf zwei Arten verwenden können:

delete myObj["SomeProperty"];
delete myObj.SomeProperty;

Hoffe die zusätzlichen Infos helfen ...

Keine der vorherigen Antworten befasst sich mit der Tatsache, dass Javascript zunächst keine assoziativen Arrays hat - es gibt keinen arrayTyp als solchen, siehe typeof.

Was Javascript hat, sind Objektinstanzen mit dynamischen Eigenschaften. Wenn Eigenschaften mit Elementen einer Array-Objektinstanz verwechselt werden, muss Bad Things ™ passieren:

Problem

var elements = new Array()

elements.push(document.getElementsByTagName("head")[0])
elements.push(document.getElementsByTagName("title")[0])
elements["prop"] = document.getElementsByTagName("body")[0]

console.log("number of elements: ", elements.length)   // returns 2
delete elements[1]
console.log("number of elements: ", elements.length)   // returns 2 (?!)

for (var i = 0; i < elements.length; i++)
{
   // uh-oh... throws a TypeError when i == 1
   elements[i].onmouseover = function () { window.alert("Over It.")}
   console.log("success at index: ", i)
}

Lösung

Verwenden Sie: Eine universelle Entfernungsfunktion, die Sie nicht in die Luft jagt:

Object.prototype.removeItem = function (key) {
   if (!this.hasOwnProperty(key))
      return
   if (isNaN(parseInt(key)) || !(this instanceof Array))
      delete this[key]
   else
      this.splice(key, 1)
};

//
// Code sample.
//
var elements = new Array()

elements.push(document.getElementsByTagName("head")[0])
elements.push(document.getElementsByTagName("title")[0])
elements["prop"] = document.getElementsByTagName("body")[0]

console.log(elements.length)                        // returns 2
elements.removeItem("prop")
elements.removeItem(0)
console.log(elements.hasOwnProperty("prop"))        // returns false as it should
console.log(elements.length)                        // returns 1 as it should

Durch das Entfernen wird nur das Objekt gelöscht, die Array-Länge bleibt jedoch gleich.

Zum Entfernen müssen Sie Folgendes tun:

array.splice(index, 1);

Während die akzeptierte Antwort korrekt ist, fehlt die Erklärung, warum sie funktioniert.

Zunächst sollte Ihr Code die Tatsache widerspiegeln, dass dies KEIN Array ist:

var myObject = new Object();
myObject["firstname"] = "Bob";
myObject["lastname"] = "Smith";
myObject["age"] = 25;

Beachten Sie, dass alle Objekte (einschließlich Arrays) auf diese Weise verwendet werden können. Erwarten Sie jedoch nicht, dass Standard-JS-Array-Funktionen (Pop, Push, ...) an Objekten funktionieren!

Wie in der akzeptierten Antwort angegeben, können Sie dann deletedie Einträge von Objekten entfernen:

delete myObject["lastname"]

Sie sollten entscheiden, welche Route Sie nehmen möchten - entweder Objekte (assoziative Arrays / Wörterbücher) oder Arrays (Karten) verwenden. Mischen Sie niemals die beiden.

Verwenden Sie die Methode splice, um Elemente vollständig aus einem Objektarray zu entfernen:

Object.prototype.removeItem = function (key, value) {
    if (value == undefined)
        return;

    for (var i in this) {
        if (this[i][key] == value) {
            this.splice(i, 1);
        }
    }
};

var collection = [
    { id: "5f299a5d-7793-47be-a827-bca227dbef95", title: "one" },
    { id: "87353080-8f49-46b9-9281-162a41ddb8df", title: "two" },
    { id: "a1af832c-9028-4690-9793-d623ecc75a95", title: "three" }
];

collection.removeItem("id", "87353080-8f49-46b9-9281-162a41ddb8df");

Wie andere Antworten bereits festgestellt haben, verwenden Sie kein Javascript-Array, sondern ein Javascript-Objekt, das in anderen Sprachen fast wie ein assoziatives Array funktioniert, mit der Ausnahme, dass alle Schlüssel in Zeichenfolgen konvertiert werden. Die neue Karte speichert Schlüssel als ihren ursprünglichen Typ.

Wenn Sie ein Array und kein Objekt hatten, können Sie die Filterfunktion des Arrays verwenden , um ein neues Array ohne das zu entfernende Element zurückzugeben:

var myArray = ['Bob', 'Smith', 25];
myArray = myArray.filter(function(item) {
    return item !== 'Smith';
});

Wenn Sie einen älteren Browser und jQuery haben, verfügt jQuery über eine $.grepMethode , die ähnlich funktioniert:

myArray = $.grep(myArray, function(item) {
    return item !== 'Smith';
});

Im Airbnb Style Guide gibt es eine elegante Möglichkeit, dies zu tun (ES7):

const myObject = {
  a: 1,
  b: 2,
  c: 3
};
const { a, ...noA } = myObject;
console.log(noA); // => { b: 2, c: 3 }

Copyright: https://codeburst.io/use-es2015-object-rest-operator-to-omit-properties-38a3ecffe90

Wenn Sie Object verwenden, haben Sie zunächst kein assoziatives Array. Bei einem assoziativen Array sieht das Hinzufügen und Entfernen von Elementen folgendermaßen aus:

    Array.prototype.contains = function(obj) 
    {
        var i = this.length;
        while (i--) 
        {
            if (this[i] === obj) 
            {
                return true;
            }
        }
        return false;
    }


    Array.prototype.add = function(key, value) 
    {
        if(this.contains(key))
            this[key] = value;
        else
        {
            this.push(key);
            this[key] = value;
        }
    }


    Array.prototype.remove = function(key) 
    {
        for(var i = 0; i < this.length; ++i)
        {
            if(this[i] == key)
            {
                this.splice(i, 1);
                return;
            }
        }
    }



    // Read a page's GET URL variables and return them as an associative array.
    function getUrlVars()
    {
        var vars = [], hash;
        var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');

        for(var i = 0; i < hashes.length; i++)
        {
            hash = hashes[i].split('=');
            vars.push(hash[0]);
            vars[hash[0]] = hash[1];
        }

        return vars;
    }



    function ForwardAndHideVariables() {
        var dictParameters = getUrlVars();

        dictParameters.add("mno", "pqr");
        dictParameters.add("mno", "stfu");

        dictParameters.remove("mno");



        for(var i = 0; i < dictParameters.length; i++)
        {
            var key = dictParameters[i];
            var value = dictParameters[key];
            alert(key + "=" + value);
        }
        // And now forward with HTTP-POST
        aa_post_to_url("Default.aspx", dictParameters);
    }


    function aa_post_to_url(path, params, method) {
        method = method || "post";

        var form = document.createElement("form");

        //move the submit function to another variable
        //so that it doesn't get written over if a parameter name is 'submit'
        form._submit_function_ = form.submit;

        form.setAttribute("method", method);
        form.setAttribute("action", path);

        for(var i = 0; i < params.length; i++)
        {
            var key = params[i];

            var hiddenField = document.createElement("input");
            hiddenField.setAttribute("type", "hidden");
            hiddenField.setAttribute("name", key);
            hiddenField.setAttribute("value", params[key]);

            form.appendChild(hiddenField);
        }

        document.body.appendChild(form);
        form._submit_function_(); //call the renamed function
    }

Sie können einen Eintrag aus Ihrer Karte entfernen, indem Sie ihn explizit 'undefined' zuweisen. Wie in Ihrem Fall:

myArray ["Nachname"] = undefiniert;

Wenn aus irgendeinem Grund der Löschschlüssel nicht funktioniert (als ob er bei mir nicht funktioniert hätte)

Sie können es herausspleißen und dann die undefinierten Werte filtern

// to cut out one element via arr.splice(indexToRemove, numberToRemove);
array.splice(key, 1)
array.filter(function(n){return n});

Versuchen Sie nicht, sie zu verketten, da der Spleiß entfernte Elemente zurückgibt.

Wir können es auch als Funktion verwenden. Angular löst einen Fehler aus, wenn er als Prototyp verwendet wird. Danke @HarpyWar. Es hat mir geholfen, ein Problem zu lösen.

var removeItem = function (object, key, value) {
    if (value == undefined)
        return;

    for (var i in object) {
        if (object[i][key] == value) {
            object.splice(i, 1);
        }
    }
};

var collection = [
    { id: "5f299a5d-7793-47be-a827-bca227dbef95", title: "one" },
    { id: "87353080-8f49-46b9-9281-162a41ddb8df", title: "two" },
    { id: "a1af832c-9028-4690-9793-d623ecc75a95", title: "three" }
];

removeItem(collection, "id", "87353080-8f49-46b9-9281-162a41ddb8df");

Es ist sehr einfach, wenn Sie die Abhängigkeit von underscore.js in Ihrem Projekt haben -

_.omit(myArray, "lastname")

Mit dem "delete"Schlüsselwort wird das Array-Element in Javascript aus dem Array gelöscht.

Zum Beispiel,

Betrachten Sie die folgenden Aussagen.

var arrayElementToDelete = new Object();

arrayElementToDelete["id"]           = "XERTYB00G1"; 
arrayElementToDelete["first_name"]   = "Employee_one";
arrayElementToDelete["status"]       = "Active"; 

delete arrayElementToDelete["status"];

In der letzten Zeile des Codes wird das Array-Element, dessen Schlüssel "Status" ist, aus dem Array entfernt.

var myArray = newmyArray = new Object(); 
myArray["firstname"] = "Bob";
myArray["lastname"] = "Smith";
myArray["age"] = 25;

var s = JSON.stringify(myArray);

s.replace(/"lastname[^,}]+,/g,'');
newmyArray = JSON.parse(p);

Ohne Schleifen / Iterationen erhalten wir das gleiche Ergebnis

Für "Arrays":

Wenn Sie den Index kennen:

array.splice(index, 1);

Wenn Sie den Wert kennen:

function removeItem(array, value) {
    var index = array.indexOf(value);
    if (index > -1) {
        array.splice(index, 1);
    }
    return array;
}

Die am besten bewertete Antwort für deletefunktioniert gut bei Objekten, aber nicht für echte Arrays. Wenn ich es benutze delete, werden Elemente aus Schleifen entfernt, das Element bleibt jedoch unverändertempty und die Länge des Arrays ändert sich nicht. Dies kann in einigen Szenarien ein Problem sein.

Wenn ich zum Beispiel myArray.toString () auf myArray nach dem Entfernen über mache delete, wird ein leerer Eintrag erstellt, dh ,,

Die einzige Arbeitsmethode für mich:

function removeItem (array, value) {
    var i = 0;
    while (i < array.length) {
        if(array[i] === value) {
            array.splice(i, 1);
        } else {
            ++i;
        }
    }
    return array;
}

Verwendungszweck:

var new = removeItem( ["apple","banana", "orange"],  "apple");
// ---> ["banana", "orange"]