Supposons que j'ai ce code:

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

Maintenant, si je voulais supprimer "nom"? .... y a-t-il un équivalent de
myArray["lastname"].remove()?

(J'ai besoin que l'élément disparaisse parce que le nombre d'éléments est important et je veux garder les choses propres.)

Les objets en JavaScript peuvent être considérés comme des tableaux associatifs, mappant des clés (propriétés) à des valeurs.

Pour supprimer une propriété d'un objet en JavaScript, vous utilisez l' deleteopérateur:

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

Notez que lorsqu'il deleteest appliqué à une propriété d'index d'un Array, vous créerez un tableau peu peuplé (c'est-à-dire un tableau avec un index manquant).

Lorsque vous travaillez avec des instances de Array, si vous ne souhaitez pas créer un tableau peu peuplé - et ce n'est généralement pas le cas -, vous devez utiliser Array#spliceou Array#pop.

Notez que l' deleteopérateur en JavaScript ne libère pas directement la mémoire. Son but est de supprimer les propriétés des objets. Bien sûr, si une propriété en cours de suppression contient la seule référence restante à un objet o, elle osera par la suite récupérée de manière normale.

L'utilisation de l' deleteopérateur peut affecter la capacité des moteurs JavaScript à optimiser le code .

Tous les objets en JavaScript sont implémentés en tant que tables de hachage / tableaux associatifs. Donc, ce qui suit est l'équivalent:

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

Et, comme déjà indiqué, vous "supprimez" une propriété d'un objet via le deletemot - clé, que vous pouvez utiliser de deux manières:

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

J'espère que les informations supplémentaires vous aideront ...

Aucune des réponses précédentes ne traite du fait que Javascript n'a pas de tableaux associatifs pour commencer - il n'y a pas de arraytype en tant que tel, voir typeof.

Ce que Javascript a, ce sont des instances d'objets avec des propriétés dynamiques. Lorsque les propriétés sont confondues avec des éléments d'une instance d'objet Array, alors Bad Things ™ est susceptible de se produire:

Problème

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)
}

Solution

Pour avoir une fonction de suppression universelle qui ne vous explose pas, utilisez:

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

Cela ne supprime que l'objet, mais conserve la même longueur de tableau.

Pour supprimer, vous devez faire quelque chose comme:

array.splice(index, 1);

Bien que la réponse acceptée soit correcte, il manque l'explication pourquoi cela fonctionne.

Tout d'abord, votre code doit refléter le fait qu'il ne s'agit PAS d' un tableau:

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

Notez que tous les objets (y compris Arrays) peuvent être utilisés de cette façon. Cependant, ne vous attendez pas à ce que les fonctions de tableau JS standard (pop, push, ...) fonctionnent sur les objets!

Comme indiqué dans la réponse acceptée, vous pouvez ensuite utiliser deletepour supprimer les entrées des objets:

delete myObject["lastname"]

Vous devez décider de l'itinéraire que vous souhaitez emprunter - utilisez des objets (tableaux associatifs / dictionnaires) ou utilisez des tableaux (cartes). Ne mélangez jamais les deux.

Utilisez la méthode splicepour supprimer complètement l'élément d'un tableau d'objets:

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");

Comme d'autres réponses l'ont noté, ce que vous utilisez n'est pas un tableau Javascript, mais un objet Javascript, qui fonctionne presque comme un tableau associatif dans d'autres langues, sauf que toutes les clés sont converties en chaînes. La nouvelle carte stocke les clés comme leur type d'origine.

Si vous aviez un tableau et non un objet, vous pouvez utiliser la fonction .filter du tableau , pour renvoyer un nouveau tableau sans l'élément que vous souhaitez supprimer:

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

Si vous avez un navigateur plus ancien et jQuery, jQuery a une $.grepméthode qui fonctionne de la même manière:

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

Il existe une manière élégante dans Airbnb Style Guide de le faire (ES7):

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

Droit d'auteur: https://codeburst.io/use-es2015-object-rest-operator-to-omit-properties-38a3ecffe90

Vous utilisez Object, vous n'avez pas de tableau associatif pour commencer. Avec un tableau associatif, l'ajout et la suppression d'éléments se fait comme suit:

    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
    }

Vous pouvez supprimer une entrée de votre carte en l'affectant explicitement à «non défini». Comme dans votre cas:

myArray ["lastname"] = undefined;

Si pour une raison quelconque, la touche de suppression ne fonctionne pas (comme si elle ne fonctionnait pas pour moi)

Vous pouvez l'épisser puis filtrer les valeurs indéfinies

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

N'essayez pas de les enchaîner car l'épissure renvoie les éléments supprimés;

Nous pouvons également l'utiliser comme fonction. Angular génère une erreur s'il est utilisé comme prototype. Merci @HarpyWar. Cela m'a aidé à résoudre un problème.

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");

C'est très simple si vous avez une dépendance underscore.js dans votre projet -

_.omit(myArray, "lastname")

En utilisant le "delete"mot - clé, il supprimera l'élément de tableau du tableau en javascript.

Par exemple,

Considérez les déclarations suivantes.

var arrayElementToDelete = new Object();

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

delete arrayElementToDelete["status"];

La dernière ligne du code supprimera l'élément du tableau dont la clé est "status" du tableau.

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);

Sans boucle / itération nous obtenons le même résultat

Pour les "tableaux":

Si vous connaissez l'indice:

array.splice(index, 1);

Si vous connaissez la valeur:

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

La réponse la plus appréciée pour deletefonctionne bien dans le cas d'objets mais pas pour les vrais tableaux. Si je l'utilise, deleteil supprime les éléments des boucles mais conserve l'élément au fur emptyet à mesure que la longueur du tableau ne change pas. Cela peut être un problème dans certains scénarios.

Par exemple, si je fais myArray.toString () sur myArray après la suppression via delete il crée une entrée vide, c'est-à-dire ,,

La seule méthode de travail pour moi:

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

usage:

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