Comment puis-je supprimer une propriété d'un objet JavaScript?

Opérateur delete est lent de façon inattendue!

Regarder la référence.

Supprimer est le seul vrai moyen de supprimer les propriétés de l'objet, sans restes, mais il fonctionne ~ 100 fois plus lent,
par rapport à son "alternative", la mise en object[key] = undefined.

Cette solution n'est pas la bonne réponse à cette question! Mais, si vous l'utilisez avec soin, vous pouvez accélérer considérablement certains algorithmes. Si vous utilisez delete en boucle et vous avez des problèmes avec la performance, de lire l'explication détaillé.

Quand doit-on utiliser delete et lorsque la valeur définie pour undefined ?

Un objet peut être vu comme un ensemble de paires clé-valeur. Ce que j'appelle une "valeur" est une primitive ou une référence à un autre objet, connecté à la "clé".

Utilisation delete, lorsque vous êtes de passage de l'objet de résultat pour le code sur lequel vous n'avez pas le contrôle (ou lorsque vous n'êtes pas sûr de votre équipe ou vous-même).

Il supprime la clé de la table de hachage.

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

Utilisez le réglage de undefined, quand vous vous souciez de la performance. Il peut donner un sérieux coup de pouce à votre code.

La clé reste sur sa place dans la table de hachage, seule la valeur est remplacée par undefined. Comprendre, que for..in boucle sera toujours effectuer une itération sur cette touche.

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

À l'aide de cette méthode, et non tous les des moyens de détermination de l'existence de la propriété fonctionnera comme prévu.

Toutefois, ce code:

object.field === undefined

va se comporter de manière équivalente pour les deux méthodes.

Tests

Pour résumer, les différences sont toutes des façons de déterminer l'existence de la propriété, et sur for..in boucle.

 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. *');

Méfiez-Vous Des Fuites De Mémoire!

Tout en utilisant obj[prop] = undefined est plus rapide que de le faire delete obj[prop], une autre considération importante est que obj[prop] = undefined ne sont pas toujours appropriées. delete obj[prop] supprime prop de obj et efface de la mémoire alors que obj[prop] = undefined suffit simplement de définir la valeur de prop à undefined qui laisse prop encore en mémoire. Par conséquent, dans le cas où il y a beaucoup de touches d'être créés et supprimés, à l'aide de obj[prop] = undefined pouvez forcer cher la mémoire de la réconciliation (causant la page de gel) et potentiellement une erreur de mémoire. Examinez le code suivant.

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

Dans le code ci-dessus, il suffit de faire nodeRecords[i][lastTime] = undefined; sera la cause d'une énorme fuite de mémoire parce que chaque image d'animation. Chaque cadre, tous les 65536 des éléments du DOM va prendre un autre 65536 emplacements individuels, mais le précédent 65536 machines à sous vont seulement être indéfinie qui laisse pendre dans la mémoire. Allez-y, essayez d'exécuter le code ci-dessus dans la console et voir par vous-même. Après avoir forcé une erreur de mémoire, essayez de l'exécuter à nouveau, sauf avec la version suivante du code qui utilise la delete opérateur à la place.

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

Comme on le voit dans l'extrait de code ci-dessus, il existe quelques rares appropriées en cas d'utilisation pour le delete de l'opérateur. Cependant, ne vous inquiétez pas à propos de ce problème de trop. Cela ne devienne un problème avec longue durée de vie des objets d'obtenir de nouvelles clés constamment ajoutés. Dans les autres cas (ce qui est presque tous les cas dans le monde réel, programmation), il est plus approprié d'utiliser obj[prop] = undefined. Le but principal de cette section est juste de porter cette question à votre attention afin que, dans les rares chances pour que cela ne devient un problème dans votre code, vous pouvez plus facilement comprendre le problème et de ne plus avoir à perdre des heures à disséquer votre code de localiser et de comprendre ce problème.

Ne Sont Pas Toujours Mis À undefined

Un aspect de Javascript qui est important à considérer est le polymorphisme. Le polymorphisme est lors de l'attribution de la même variable/fente-dans-un-objet de différents types comme vu ci-dessous.

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

Cependant, il existe deux grands irrécupérable problèmes avec les tableaux polymorphes:

1. Ils sont lents & mémoire inefficace. Lors de l'accès à un index spécifique, au lieu de simplement obtenir le type globaux pour le tableau, le navigateur dispose en revanche d'obtenir le type par l'indice de base en vertu de laquelle chaque index stocke les métadonnées supplémentaires de ce type.
2. Une fois polymorphe, toujours polymorphes. Lorsqu'un tableau est fait polymorphe, le polymorphisme ne peut pas être annulée dans les navigateurs Webkit. Donc, même si vous restaurez un tableau polymorphe d'être non polymorphes, il sera toujours stocké par le navigateur comme un polymorphe tableau.

On peut comparer le polymorphisme pour un problème de toxicomanie. À première vue, il semble incroyablement lucrative: très jolis moelleux code. Ensuite, le codeur présente son tableau à la drogue de polymorphisme. Instantanément, le polymorphe tableau devient de moins en moins efficace, et il ne peut jamais devenir aussi efficace qu'il l'était avant, car il est drogué. Une corrélation, une telle circonstance de la vie réelle, quelqu'un de la cocaïne pourrait même ne pas être capable de l'exploitation d'une simple poignée de porte, encore moins être en mesure de calculer les décimales de PI. De même, un tableau sur le médicament de polymorphisme ne peut jamais être aussi efficace qu'un monomorphe tableau.

Mais, comment un médicament analogie voyage se rapportent à la delete opération? La réponse est inhérent à la dernière ligne de code dans l'extrait ci-dessus. Donc permettez d'être réexaminés, cette fois avec une torsion.

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

Observer. bar[1] = "" ne pas contraindre le polymorphisme alors que bar[1] = undefined n'. Par conséquent, on devrait toujours, chaque fois que possible, utiliser le type correspondant pour leurs objets, afin de ne pas accidentellement provoquer le polymorphisme. Une telle personne peut utiliser la liste suivante comme une référence générale pour les faire aller. Cependant, veuillez ne pas utiliser explicitement la ci-dessous des idées. Au lieu de cela, utiliser ce qui fonctionne bien pour votre code.

• Lors de l'utilisation d'un tableau/variable de type booléen primitive, utilisez false ou undefined que la valeur vide. Tout en évitant les polymorphisme est bonne, la réécriture de tous vos codes d'interdire explicitement, il ne sera probablement entraîner une diminution des performances. Utilisez votre bon jugement!
• Lors de l'utilisation d'un tableau/variable typée pour le nombre primitif, l'utilisation 0 que la valeur vide. Notez que, en interne, il y a deux types de nombres: rapide entiers (2147483647 de -2147483648 inclus) et lent à virgule flottante en double (autre chose que cela, y compris NaN et Infinity). Quand un nombre entier est rétrogradé à une double, il ne peut pas être promus à un entier.
• Lors de l'utilisation d'un tableau/variable tapé à la primitive de chaîne, utilisez "" que la valeur vide.
• Lors de l'utilisation d'un Symbole, d'attendre, pourquoi êtes-vous à l'aide d'un Symbole?!?! Les symboles sont mauvais juju pour la performance. Tout programmé pour utiliser les Symboles peuvent être reprogrammées pour ne pas utiliser de Symboles, résultant en une plus de code sans Symboles. Les symboles sont vraiment super juste inefficace méta-sucre.
• Lors de l'utilisation de tout autre chose, l'utilisation null.

Cependant, être conscient! Ne pas soudainement commencer à faire cela avec tous vos préexistante code maintenant qu'elle irait à l'encontre de ces derniers code et/ou d'introduire des bugs étranges. Plutôt, une pratique efficiente doit être mis en œuvre dès le début, et lors de la conversion de code préexistant, il est recommandé que vous double, triple, quadruple vérifier toutes les lignes relatives à cette tentative de mise à niveau de l'ancien code de cette nouvelle pratique peut être aussi risqué que c'est gratifiant.

Mise à jour 2018-07-21: Pendant un long moment, j'ai senti gêné à propos de cette réponse, donc je pense qu'il est temps que je le touche un peu. Juste un petit commentaire, de clarification et de mise en forme pour aider à accélérer la lecture de la inutilement long et alambiqué parties de cette réponse.

---

LA VERSION COURTE

La réponse exacte à la question

Comme d'autres l'ont dit, vous pouvez utiliser delete.

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

Tableau équivalent

Ne pas delete à partir d'un tableau. Utilisation Array.prototype.splice à la place.

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

---

LA VERSION LONGUE

JavaScript est un Langage de programmation orientée objet, donc tout est un objet, y compris tableaux. Donc, je pense qu'il faut une mise en garde.

Dans des tableaux, à la différence de la plaine de vieux objets, à l'aide delete laisse derrière lui des ordures dans la forme de null, la création d'un "trou" dans le tableau.

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

Comme vous pouvez le voir, delete ne fonctionnent pas toujours comme on pourrait s'y attendre. La valeur est écrasée, mais la mémoire n'est pas réaffecté. C'est-à-dire, array[4] n'est pas relocalisé à array[3]. Ce qui est en contraste à Array.prototype.unshift, qui insère un élément au début du tableau et décale tout vers le haut (array[0] devient array[1], etc.)

Honnêtement, outre la définition de null plutôt que undefined--qui est légitimement bizarre--ce comportement ne devrait pas être surprenant, étant donné que delete est un opérateur unaire, comme typeof, c'est-durs dans la langue et n'est pas censé se soucient de la type de l'objet, il est utilisé, alors que Array est une sous-classe de Object avec des méthodes spécialement conçu pour travailler avec des tableaux. Donc il n'y a aucune bonne raison pour delete d'avoir un cas spécial cuit dans de re-déplacer le tableau, car cela ne ferait que ralentir les choses avec le travail inutile. Rétrospectivement, mes attentes étaient irréalistes.

Bien sûr, il ne une surprise pour moi. Parce que j'ai écrit cela pour justifier ma croisade contre les "null ordures":

Ignorer les dangers et les problèmes inhérents à null, et l'espace gaspillé, cela peut être problématique si le tableau doit être précis.

Qui est un terrible justification pour se débarrasser de la nulls--null est seulement dangereux si mal utilisé, et il n'a rien à voir avec "précision". La vraie raison pour laquelle vous ne devriez pas delete à partir d'un tableau est de laisser des ordures remplis et désordonné des structures de données autour de est bâclée et bug sur le ventre.

Ce qui suit est artificiel, scénario qui obtient assez de longue haleine, de sorte que vous pouvez passer à la section La Solution, si vous le souhaitez. La seule raison pour laquelle je quitte cette section c'est que je pense que certaines personnes pensent probablement que c'est drôle, et je ne veux pas être "ce mec" qui publie un "drôle" de répondre, puis supprime tous les "drôle" de cela plus tard.

...C'est stupide, je sais.

L'artificiel et de longue haleine PDP-11 scénario

Par exemple, dire que vous êtes la création d'une webapp qui utilise JSON-sérialisation pour stocker un tableau utilisé pour les "onglets" dans une chaîne (dans ce cas, localStorage). Disons aussi que le code utilise les indices numériques de la matrice de la "titre" quand le dessin à l'écran. Pourquoi faites-vous cela plutôt que de simplement stocker le "titre" ainsi? Parce que... raisons.

Ok, disons que vous essayez d'économiser de la mémoire, à la demande de ce un utilisateur qui exécute un PDP-11 mini-ordinateurs depuis les années 1960 fonctionnant sous UNIX et écrit son propre Elinks base, JavaScript-conforme, ligne-printer-friendly navigateur parce que X11 est hors de question.

De plus en plus stupide bord scénario de côté, en utilisant delete sur ladite matrice de résultat dans null de polluer le tableau, et probablement à l'origine de bugs dans l'application plus tard. Et si vous vérifiez pour null, il serait droite jusqu'à ignorer les chiffres résultant dans les onglets en cours de rendu comme [1] [2] [4] [5] ....

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

Oui, c'est certainement pas ce que tu voulais.

Maintenant, vous pourrait conserver une deuxième itération, comme j, pour incrémenter uniquement lorsque les valeurs valides sont lues à partir de la matrice. Mais ce ne serait pas exactement résoudre le null question, et vous avez encore du plaisir que troll PDP-11 de l'utilisateur. Hélas, son ordinateur juste n'est pas avoir assez de mémoire pour contenir cette dernière entier _{(ne me demandez pas comment il arrive à gérer une largeur variable de tableau...)}.

Donc, il vous envoie un mail dans la colère:

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

Maintenant, vous êtes au bout du rouleau. Ce mec a été se plaindre non-stop sur votre application, et que vous voulez lui dire de la fermer et d'aller prendre un meilleur ordinateur.

La Solution: Array.prototype.splice

Heureusement, les tableaux ne ont une méthode spécialisée pour la suppression d'indices et de réaffectation de mémoire: Array.prototype.splice(). Vous pouvez écrire quelque chose comme ceci:

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

Et juste comme ça, vous êtes heureux que M. PDP-11. Hourra! _{(j'aurais quand même le lui dire, mais...)}

Tableau.le prototype.splice vs Tableau.le prototype.tranche

Je pense qu'il est important de souligner la différence entre ces deux même nom de fonctions, comme ils sont à la fois très utile.

Tableau.le prototype.splice(démarrer, n)

.splice() se transforme le tableau, et renvoie l'retirée des indices. Le tableau est coupé à partir de l'index, start, et n éléments sont découpées. Si n n'est pas spécifié, l'ensemble de la matrice après start est découpées (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]

Tableau.le prototype.tranche(début, fin)

.slice() est non destructif et renvoie un nouveau tableau contenant l'indication des indices de start à end. Si end n'est spécifié, le comportement est le même que .splice() (end = array.length). Le comportement est un peu délicate, car, pour une raison quelconque, end index à partir de 1 au lieu de 0. Je ne sais pas pourquoi il fait cela, mais c'est comment il est. Aussi, si end <= start, le résultat est un tableau vide.

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]

Ce n'est pas vraiment ce qui se passe, mais il est plus facile de penser de cette façon. Selon le MDN, voici ce qui se passe vraiment:

//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

L'index spécifié par end est tout simplement exclus de la tranche. La mise entre parenthèses des indices indiquent ce qui est tranché. De toute façon, le comportement n'est pas intuitif, et il est lié à provoquer sa juste part de tout-en-un d'erreurs, de sorte que vous pourriez trouver utile de faire une fonction wrapper de plus près à émuler le comportement de .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);
}

Noter que la fonction wrapper est conçu pour être très strict sur les types, et sera de retour null si quelque chose est éteint. Qui comprend la mise en une chaîne de caractères comme "3". Il est laissé au programmeur de faire preuve de diligence au sujet de ses types. C'est pour encourager les bonnes de la programmation de la pratique.

Mise à jour concernant is_array()

C'est en ce qui concerne ce (maintenant supprimé) extrait de:

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

Donc comme il s'avère, il ya effectivement un moyen intégré pour savoir si un tableau est vraiment un tableau, et c'est Array.isArray(), introduit dans ECMAScript 5 (décembre 2009). J'ai trouvé cela tout à la recherche pour voir si il y avait une question à poser au sujet de raconter des tableaux à partir d'objets, pour voir si il y avait une meilleure solution que la mienne, ou pour ajouter le mien si il n'y en avait aucune. Donc, si vous utilisez une version de JavaScript qui est antérieure à l'ECMA 5, il y a votre polyfill. Toutefois, je recommande fortement contre l'utilisation de mon is_array() fonction, en tant que de continuer à supporter les anciennes versions de JavaScript, c'est continuer à soutenir les anciens navigateurs qui les mettent en œuvre, ce qui signifie encourager l'utilisation des logiciels vulnérables et de mettre les utilisateurs à risque pour les logiciels malveillants. Donc, s'il vous plaît, utilisez Array.isArray(). Utilisation let et const. Utiliser les nouvelles fonctionnalités sont ajoutées à la langue. Ne pas utiliser des fournisseurs de préfixes. Supprimer que IE polyfill de la merde de votre site web. Supprimer XHTML <!CDATA[[... de la merde, trop--nous avons déménagé à HTML5 de retour en 2014. Le plus tôt que tout le monde se retire soutien pour ces vieux/ésotérique navigateurs, le plus tôt sera le navigateur vendeurs suivent le standard du web et utiliser la nouvelle technologie, et le plus tôt nous pouvons passer à un plus web sécurisé.

Une autre alternative est d'utiliser la Underscore.js de la bibliothèque.

Noter que _.pick() et _.omit() à la fois de renvoyer une copie de l'objet, et ne pas modifier directement l'objet d'origine. L'affectation du résultat de l'objet d'origine devrait faire l'affaire (non illustré).

Référence: lien _.pick(objet, *les touches)

De renvoyer une copie de l'objet, filtrée uniquement de valeurs pour l'
dans la liste blanche des touches (ou un tableau de clés valides).

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

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

Référence: lien _.omettre(objet, *les touches)

De renvoyer une copie de l'objet, filtrée à omettre la
sur la liste noire des clés (ou d'une matrice de touches).

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

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

Pour les tableaux, _.filter() et _.reject() peut être utilisée de manière similaire.

Le terme que vous avez utilisé dans votre question titre Remove a property from a JavaScript object, peut être interprété de différentes façons. L'un est à retirer pour l'ensemble de la mémoire et de la liste des clés de l'objet ou de l'autre, c'est juste pour le supprimer de votre objet. Comme il a été mentionné dans d'autres réponses, le delete mot-clé est la partie principale. Disons que vous avez votre objet comme:

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

Si vous n':

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

le résultat serait:

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

Vous pouvez supprimer cette touche spécifique de vos clés de l'objet comme:

delete myJSONObject["regex"];

Ensuite votre clé objets à l'aide de Object.keys(myJSONObject) serait:

["ircEvent", "method"]

Mais le point est que si vous vous souciez de la mémoire et que vous souhaitez à l'ensemble de l'objet est supprimé de la mémoire, il est recommandé de le mettre à null avant de supprimer la clé:

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

L'autre point important ici est d'être prudent quant à vos autres références pour le même objet. Par exemple, si vous créez une variable comme:

var regex = myJSONObject["regex"];

Ou d'ajouter un nouveau pointeur vers un autre objet, comme:

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

Alors, même si vous retirez de votre objet myJSONObject, cet objet spécifique ne sera pas supprimé de la mémoire, depuis le regex variable et myOtherObject["regex"] ont encore leurs valeurs. Alors comment pourrions-nous retirer l'objet de la mémoire pour vous?

La réponse serait à supprimer toutes les références que vous avez dans votre code, a souligné que l'objet même et aussi pas utiliser var états à créer de nouvelles références à cet objet. Ce dernier point concernant var états, est l'une des questions les plus cruciales que nous sommes habituellement en face de vous, parce que l'utilisation de var états de prévenir l'objet créé à partir d'obtenir supprimé.

Ce qui signifie dans ce cas, vous ne serez pas en mesure de supprimer cet objet parce que vous avez créé le regex variable par l'intermédiaire d'un var déclaration, et si vous n':

delete regex; //False

Le résultat serait false, ce qui signifie que votre instruction delete n'ont pas été exécutées comme prévu. Mais si vous n'avez pas créé cette variable avant, et vous n'aviez myOtherObject["regex"] que votre dernière référence existante, vous auriez pu faire cela simplement en enlevant comme:

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

En d'autres termes, un objet JavaScript se fait tuer dès qu'il n'y a pas de référence à gauche dans votre code de relever à cet objet.

---

Mise à jour:
Grâce à @AgentME:

Définition d'une propriété à null avant de le supprimer, il n'est pas accomplir
quoi que ce soit (sauf si l'objet a été scellé par un Objet.joint d'étanchéité et l'
supprimer échoue. Ce n'est généralement pas le cas sauf si vous
essayez).

Pour obtenir plus d'infos sur Object.seal: Objet.le joint d'étanchéité()

Supposons que vous avez un objet qui ressemble à ceci:

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

La suppression d'un objet de propriété

Si vous souhaitez utiliser la totalité de la staff tableau, la bonne façon de le faire, serait de faire ceci:

delete Hogwarts.staff;

Alternativement, vous pouvez aussi faire ceci:

delete Hogwarts['staff'];

De même, la suppression de l'ensemble des étudiants de la matrice serait fait en appelant delete Hogwarts.students; ou delete Hogwarts['students'];.

La suppression d'un index de tableau

Maintenant, si vous souhaitez supprimer un seul membre du personnel ou étudiant, la procédure est un peu différente, parce que les deux propriétés sont des tableaux eux-mêmes.

Si vous connaissez l'index de votre membre du personnel, vous pourriez simplement faire ceci:

Hogwarts.staff.splice(3, 1);

Si vous ne connaissez pas l'index, vous aurez également à faire une recherche d'index:

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

---

Remarque

Alors que vous techniquement pouvez utiliser delete pour un tableau, en l'utilisant, on obtiendra des résultats incorrects lors de l'appel par exemple Hogwarts.staff.length plus tard. En d'autres termes, delete de supprimer l'élément, mais il ne serait pas de mise à jour de la valeur de length de la propriété. À l'aide de delete serait également gâcher votre indexation.

Donc, lors de la suppression de valeurs d'un objet, toujours d'abord vous demander si vous avez à traiter avec des propriétés de l'objet ou si vous avez à traiter avec des valeurs de tableau, et de choisir la stratégie appropriée sur cette base.

Si vous voulez expérimenter avec cela, vous pouvez utiliser ce Violon comme un point de départ.

La opérateur delete est la meilleure façon de le faire.

Un exemple vivant à spectacle:

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); //Logs false, because bar was deleted from foo.

À l'aide de supprimer méthode est la meilleure façon de le faire, comme par MDN description, l'opérateur delete supprime une propriété d'un objet. Ainsi, vous pouvez simplement écrire:

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

L'opérateur delete supprime une propriété d'un objet. Sur
la suppression réussie, elle renvoie true, sinon false sera retourné.
Cependant, il est important de considérer les scénarios suivants:

• Si la propriété que vous cherchez à supprimer n'existe pas, supprimer
  n'aura aucun effet et sera de retour vrai

• Si une propriété portant le même nom existe sur le prototype de l'objet de
  la chaîne, puis, après la suppression, par l'objet de la propriété de l'
  chaîne de prototype (en d'autres termes, supprimer seulement a un effet propre sur
  les propriétés).

• Toute propriété déclarées avec var ne peut pas être supprimé de la portée mondiale
  ou à partir d'une fonction de la portée.

• En tant que tel, ne peut pas supprimer supprimer toutes les fonctions à portée globale (si cela fait partie de la définition d'une fonction ou d'une fonction (expression).

• Fonctions qui font partie d'un objet (en dehors de l'
  
  de portée mondiale) peuvent être supprimés avec supprimer.

• Toute propriété déclarée avec let ou const ne peut pas être supprimé à partir du champ dans lequel ils ont été définis. Non configurable propriétés ne peuvent pas être supprimés. Cela inclut les propriétés des objets intégrés comme les Mathématiques, Tableau, Objet et des propriétés qui sont créés en tant que non-configurable avec des méthodes comme Objet.defineProperty().

L'extrait de code suivant donne un autre exemple simple:

JS:

var Employee = {
      age: 28,
      name: 'Alireza',
      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

Pour en savoir plus et voir plus, visitez le lien ci-dessous:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

Pour cloner un objet sans propriété:

Par exemple:

let object = { a: 1, b: 2, c: 3 };   

Et nous avons besoin de supprimer "un".

1.Explicite prop key:

const { a, ...rest } = object;
object = rest;

2.Avec la variable prop key:

const propKey = 'a';
const { [propKey]: propValue, ...rest } = object;
object = rest;

3.Cool flèche fonction :

const removePropery = (propKey, { [propKey]: propValue, ...rest }) => rest;

object = removePropery('a', object);

4. Pour de multiples propriétés

const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})

Utilisation

object = removeProperties(object, 'a', 'b') //result => { c: 3 }

Ou

    const propsToRemove = ['a', 'b']
    object = removeProperties(object, ...propsToRemove) //result => { c: 3 }

Il y a beaucoup de bonnes réponses ici, mais je veux juste mentionner que lors de l'utilisation de supprimer pour supprimer une propriété en JavaScript, il est souvent judicieux de vérifier d'abord si la propriété existe pour éviter les erreurs.

E. g

var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

En raison de la nature dynamique de JavaScript, il y a souvent des cas où vous simplement ne sais pas si la propriété existe ou pas. Vérifier si obj existe avant le && également fait en sorte que vous ne jetez pas une erreur due à l'appel de la hasOwnProperty() de la fonction sur un objet non défini.

Désolé si cela n'a pas l'ajouter à votre cas d'utilisation spécifiques, mais je pense que c'est un bon design pour s'adapter lors de la gestion des objets et de leurs propriétés.

Essayez la méthode suivante. Attribuer le Object la valeur de la propriété à undefined. Puis stringify l'objet et parse.

JS:

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

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);

Vous pouvez simplement supprimer toute propriété d'un objet à l'aide de la delete mot-clé.

Par exemple:

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

De supprimer toute propriété, dire key1, utilisez le delete mot-clé comme ceci:

delete obj.key1

Ou vous pouvez également utiliser le tableau comme notation:

delete obj[key1]

Ref: MDN.

Envisager la création d'un nouvel objet sans le "regex" bien parce que l'original de l'objet peut toujours être référencé par d'autres parties de votre programme. Vous devriez donc éviter de les manipuler.

JS:

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

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

console.log(newMyObject);

JS:

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

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

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

Essayer cette

delete myObject['key'];

Propriété de Suppression en JavaScript

Il ya beaucoup de différentes options présentées sur cette page, non pas parce que la plupart des options sont mauvais, ou parce que les réponses sont en doubles—mais parce que la technique appropriée dépend de la situation où vous êtes et les objectifs des tâches que vous et/ou votre équipe tentent de réaliser. Pour répondre à votre question, sans équivoque, on a besoin de savoir:

1. La version de ECMAScript vous ciblez
2. La gamme des types d'objet que vous souhaitez supprimer les propriétés et le type de noms de propriété que vous devez être en mesure d'omettre (Cordes? Symboles? Références faibles mappé à partir d'objets arbitraires? Ces derniers ont été tous types de biens pointeurs en JavaScript depuis des années maintenant)
3. La programmation de l'ethos/motifs, vous et votre équipe, à utiliser. Ne vous en faveur d'approches fonctionnelles et de mutation est verboten sur votre équipe, ou avez-vous recours à l'ouest sauvage mutative techniques de programmation orientée objet?
4. Vous cherchez à atteindre cet objectif en pur JavaScript ou êtes-vous prêt & en mesure d'utiliser un 3e partie de la bibliothèque?

Une fois ces quatre questions ont été répondues, il y a essentiellement quatre catégories de propriété de "l'enlèvement" en JavaScript a choisi de partir afin de répondre à vos objectifs. Ils sont:

Mutative propriété de l'objet de la suppression, dangereux

Cette catégorie est pour les opérations sur les objets littéraux ou des instances de l'objet lorsque vous voulez garder/continuer à utiliser la référence d'origine et ne sont pas en utilisant des apatrides principes fonctionnels dans votre code. Un exemple de pièce de syntaxe dans cette catégorie:

'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

Cette catégorie est la plus ancienne, la plus simple & plus largement pris en charge catégorie de la propriété de l'enlèvement. Il prend en charge Symbol & index de tableau en plus de chaînes et fonctionne dans toutes les versions de JavaScript à l'exception de la toute première version. Cependant, il est mutative qui viole certains principes de programmation et a des implications sur les performances. Il peut également résulter de ce type d'exception lorsqu'il est utilisé sur non les propriétés configurables en mode strict.

Rest propriété de chaîne d'omission

Cette catégorie est pour exploitation sur un objet ou un tableau d'instances de nouvelles ECMAScript saveurs lorsqu'un non-mutative approche et vous n'avez pas besoin de compte pour les touches de Symbole:

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 :(

Mutative propriété de l'objet de la suppression, coffre-fort

Cette catégorie est pour les opérations sur les objets littéraux ou des instances de l'objet lorsque vous voulez garder/continuer à utiliser la référence d'origine tout en les protégeant contre les exceptions d'être jeté sur unconfigurable propriétés:

'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

En outre, alors que la mutation des objets en place n'est pas apatride, vous pouvez utiliser le caractère fonctionnel de Reflect.deleteProperty de faire une application partielle et d'autres techniques fonctionnelles qui ne sont pas possible avec delete consolidés.

La syntaxe de base de la chaîne de propriété omission

Cette catégorie est pour exploitation sur un objet ou un tableau d'instances de nouvelles ECMAScript saveurs lorsqu'un non-mutative approche et vous n'avez pas besoin de compte pour les touches de Symbole:

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 :(

Bibliothèque de base de la propriété omission

Cette catégorie est généralement permet une plus grande flexibilité fonctionnelle, y compris la comptabilité, de Symboles, & omission plus d'une propriété dans une déclaration:

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"

@johnstock, on peut aussi utiliser du JavaScript prototypage concept d'ajouter des méthodes à des objets de supprimer tout passé clés disponibles dans l'objet appelant.

Réponses ci-dessus sont appréciés.

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

//1st and direct way 
delete myObject.regex;  //delete myObject["regex"]
console.log(myObject); //{ ircEvent: 'PRIVMSG', method: 'newURI' }

 //2 way -  by using the concept of JavaScript's prototyping concept
Object.prototype.removeFromObjectByKey = function(key) {
     //If key exists, remove it and return true
     if(this[key] !== undefined) {
           delete this[key]
           return true;
     }
     //Else return false
     return false;
}

var isRemoved = myObject.removeFromObjectByKey('method')
console.log(myObject)  //{ ircEvent: 'PRIVMSG' }

//More examples
var obj = { a: 45, b: 56, c: 67}
console.log(obj) //{ a: 45, b: 56, c: 67 }

//Remove key 'a' from obj
isRemoved = obj.removeFromObjectByKey('a')
console.log(isRemoved); //true
console.log(obj); //{ b: 56, c: 67 }

//Remove key 'd' from obj which doesn't exist
var isRemoved = obj.removeFromObjectByKey('d')
console.log(isRemoved); //false
console.log(obj); //{ b: 56, c: 67 }

J'ai utilisé lodash "unset" à réaliser pour objet imbriqué aussi.. que ce besoin d'écrire de petits logique pour obtenir le chemin de la clé de propriété qui s'attend à en omettre méthode.

1. Méthode qui retourne le chemin de la propriété en tant que tableau

JS:

var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450","lt":"500"}}},{"bool":{"should":[{"term":{"color_value.keyword":"Black"}}]}}]}};

function getPathOfKey(object,key,currentPath, t){
     var currentPath = currentPath || [];

    for(var i in object){
		if(i == key){
        t = currentPath;
      }
      else if(typeof object[i] == "object"){
        currentPath.push(i)
       return getPathOfKey(object[i], key,currentPath)
      }
    }
	t.push(key);
    return t;
}
document.getElementById("output").innerHTML =JSON.stringify(getPathOfKey(a,"price_index.final_price"))

HTML:

<div id="output"> 

</div>

1. Puis juste à l'aide de lodash unset méthode de suppression de la propriété de l'objet.

JS:

var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));

Pour

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

supprimer myObject["regex"];
Aussi, vous savez index de clé , par exemple. Vous devez supprimer 2ème clé(regex)
puis

var key =  Object.keys(myObject)[2]
delete myObject[key];

Beaucoup de temps nous avons besoin de l'indice de base de la suppression dans l'objet Mais n'oubliez pas de clés dans l'objet peut être de haut en bas position de sorte s'il vous plaît attention lors de son utilisation il

Que beaucoup ont déjà dit, vous pouvez utiliser soit "supprimer"(javascript propriété) ou "annuler"(à l'aide de lodash).

Vous pouvez également utiliser lodash propriété "ramasser" de choisir seulement nécessaire propriétés de l'objet.Il aidera quand vous arrivez à la suppression de plusieurs propriétés de l'objet.

Utilisation comme ci-dessous:

var _   = require("lodash");
var obj = {"a":1, "b":2, "c":3};
obj = _.pick(obj,["a","b"]);    
//Now obj contains only 2 props {"a":1, "b":2}

Vous pouvez utiliser la notation de point ou de support de la notation

//Bracket notation 
//its direct approach when you know the exact value which you want to remove
delete myObject.regex;


//Dot Notation 
//its dynamic approach when you don't know which value you want to remove at the point of code
delete myObject['regex'];