Comment supprimer une propriété d'un objet JavaScript?
Dites que je crée un objet comme suit:
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
Quel est le meilleur moyen de supprimer la propriété regex pour obtenir le nouveau myObject comme suit?
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI"
};
Comme ça:
delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];
Démo
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
delete myObject.regex;
console.log(myObject);Pour ceux qui voudraient en savoir plus à ce sujet, l'utilisateur de Stack Overflow kangax a écrit un article de blog incroyablement détaillé sur la déclaration delete sur son blog, Comprendre supprimer. C'est fortement recommandé.
L'opérateur delete est inopinément lent!
Regardez le repère.
Supprimer est le seul véritable moyen de supprimer les propriétés de l'objet sans laisser de reste, mais cela fonctionne ~ 100 fois plus lentement , par rapport à son "alternative", définissant object[key] = undefined.
Cette alternative n'est pas la bonne réponse à cette question! Mais si vous l'utilisez avec précaution, vous pouvez considérablement accélérer certains algorithmes. Si vous utilisez delete dans des boucles et que vous rencontrez des problèmes de performances, lisez l'explication détaillée.
Quand faut-il utiliser delete et lorsque la valeur est définie sur 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é à cette "clé".
Utilisez delete, lorsque vous transmettez l'objet résultat au code sur lequel vous n'avez pas le contrôle (ou lorsque vous n'êtes pas sûr à propos de votre équipe ou de vous-même).
Il supprime la clé de la table de hachage .
var obj = {
field: 1
};
delete obj.field;
Utilisez le réglage sur undefined, lorsque vous vous souciez de la performance. Cela peut donner un sérieux coup de pouce à votre code.
La touche reste à sa place dans le hashmap , seule la valeur est remplacée par undefined. Comprenez que cette boucle for..in itérera toujours sur cette clé.
var obj = {
field: 1
};
obj.field = undefined;
En utilisant cette méthode, toutes les façons de déterminer l’existence d’une propriété fonctionneront comme prévu.
Cependant, ce code:
object.field === undefined
se comportera de manière équivalente pour les deux méthodes.
Des tests
En résumé, les différences concernent toutes les manières de déterminer l’existence de la propriété et la boucle for..in.
console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');
console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');
console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');
console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');
console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');
console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
//Object.keys().indexOf() is an overkill that runs much slower :)
var counter = 0,
key;
for (key in obj) {
counter++;
}
console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');
Méfiez-vous des fuites de mémoire!
Bien que obj[prop] = undefined soit plus rapide que delete obj[prop], il est également important de noter que obj[prop] = undefined pourrait ne pas toujours être approprié. delete obj[prop] supprime prop de obj et l'efface de la mémoire alors que obj[prop] = undefined définit simplement la valeur de prop à undefined qui laisse prop toujours en mémoire. Par conséquent, dans les cas où de nombreuses clés sont créées et supprimées, l'utilisation de obj[prop] = undefined peut forcer une réconciliation coûteuse en mémoire (provoquant le gel de la page) et éventuellement une erreur d'insuffisance 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, le simple fait de jouer nodeRecords[i][lastTime] = undefined; provoquera une fuite de mémoire massive à cause de chaque image d'animation. Chaque trame, tous les 65536 éléments DOM occupera 65536 emplacements supplémentaires, mais les 65536 précédents ne seront réglés que sur undefined, ce qui les laissera en suspens dans la mémoire. Allez-y, essayez d'exécuter le code ci-dessus dans la console et voyez par vous-même. Après avoir forcé une erreur de mémoire insuffisante, essayez de l'exécuter à nouveau, sauf avec la version suivante du code qui utilise à la place l'opérateur delete.
"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 indiqué dans l'extrait de code ci-dessus, il existe quelques rares cas d'utilisation appropriés pour l'opérateur delete. Cependant, ne vous inquiétez pas trop de ce problème. Cela ne deviendra un problème qu'avec les objets de longue durée de vie auxquels de nouvelles clés sont constamment ajoutées. Dans tous les autres cas (ce qui est presque toujours le cas dans la programmation en situation réelle), il est préférable d'utiliser obj[prop] = undefined. Le but principal de cette section est simplement de vous le signaler afin que, dans les rares cas où cela devienne un problème dans votre code, vous pourrez alors plus facilement comprendre le problème et éviter de perdre du temps à disséquer votre code pour le localiser. et comprendre ce problème.
Ne pas toujours régler sur undefined
Le polymorphisme est un aspect important à prendre en compte. Le polymorphisme est lors de l’affectation de la même variable/type d’emplacement dans un objet, comme indiqué 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 problèmes majeurs non résolus avec les tableaux polymorphes:
- Ils sont lents et la mémoire inefficace. Lors de l'accès à un index spécifique, au lieu de simplement obtenir le type global du tableau, le navigateur doit obtenir le type individuellement pour chaque index, chaque index stockant les métadonnées supplémentaires de son type.
- Une fois polymorphe, toujours polymorphe. Lorsqu'un tableau est rendu polymorphe, le polymorphisme ne peut pas être annulé dans les navigateurs Webkit. Ainsi, même si vous restaurez un tableau polymorphe non polymorphe, il restera stocké par le navigateur en tant que tableau polymorphe.
On peut comparer le polymorphisme à une toxicomanie. À première vue, cela semble incroyablement lucratif: un joli code assez moelleux. Ensuite, le codeur introduit son tableau au médicament du polymorphisme. Instantanément, la matrice polymorphe devient moins efficace et ne peut jamais devenir aussi efficace qu’avant car elle est droguée. Pour corréler de telles circonstances avec la vie réelle, une personne consommant de la cocaïne pourrait même ne pas être capable de gérer une simple poignée de porte et encore moins de pouvoir calculer les chiffres de PI. De même, un tableau sur le polymorphisme ne peut jamais être aussi efficace qu'un tableau monomorphe.
Mais, comment une analogie de sortie de drogue se rapporte-t-elle à l'opération delete? La réponse hérite de la dernière ligne de code de l'extrait ci-dessus. Laissez-le ainsi réexaminer, 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 contraint pas le polymorphisme alors que bar[1] = undefined le fait. Par conséquent, il convient de toujours, autant que possible, utiliser le type correspondant à leurs objets afin de ne pas provoquer accidentellement de polymorphisme. Une de ces personnes peut utiliser la liste suivante comme référence générale pour les lancer. Cependant, veuillez ne pas utiliser explicitement les idées ci-dessous. Au lieu de cela, utilisez ce qui fonctionne bien pour votre code.
- Lorsque vous utilisez un tableau/une variable typée dans la primitive booléenne, utilisez
falseouundefinedcomme valeur vide. Bien qu'il soit bon d'éviter le polymorphisme inutile, réécrire tout votre code pour l'interdire explicitement entraînera probablement une baisse des performances. Utilisez le jugement commun! - Lorsque vous utilisez un tableau/une variable typée dans la primitive numérique, utilisez
0comme valeur vide. Notez qu'en interne, il existe deux types de nombres: les entiers rapides (2147483647 à -2147483648 inclus) et les doubles à virgule flottante lente (autre que celui incluantNaNetInfinity). Lorsqu'un entier est rétrogradé en double, il ne peut pas être promu de nouveau en entier. - Lorsque vous utilisez un tableau/une variable typée dans la primitive de chaîne, utilisez
""comme valeur vide. - Lorsque vous utilisez un symbole, attendez, pourquoi utilisez-vous un symbole?!?! Les symboles sont mauvais pour la performance. Tout ce qui est programmé pour utiliser les symboles peut être reprogrammé pour ne pas utiliser de symboles, permettant ainsi un code plus rapide sans symboles. Les symboles ne sont que des méta-sucres super inefficaces.
- Si vous utilisez autre chose, utilisez
null.
Cependant, soyez prudent! Ne commencez pas soudainement à faire cela avec tout votre code préexistant, car cela casserait probablement ce code préexistant et/ou introduirait des bogues étranges. Une telle pratique efficace doit plutôt être mise en œuvre dès le départ et lors de la conversion de code préexistant, il est recommandé de vérifier toutes les lignes relatives à cela, car il est possible d'essayer de mettre à niveau l'ancien code vers cette nouvelle pratique. aussi risqué que gratifiant.
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
delete myObject.regex;
console.log ( myObject.regex); // logs: undefinedCela fonctionne dans Firefox et Internet Explorer, et je pense que cela fonctionne dans tous les autres.
Mise à jour 2018-07-21: Cela fait longtemps que je suis embarrassé de cette réponse. Je pense donc qu'il est temps que je retouche un peu. Juste un petit commentaire, des précisions et un formatage pour aider à accélérer la lecture des parties inutilement longues et compliquées de cette réponse.
LA VERSION COURTE
La réponse réelle à la question
Comme d'autres l'ont dit, vous pouvez utiliser delete.
obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined
Équivalent tableau
Ne pas delete d'un tableau. Utilisez 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 OOP. Tout est donc un objet, y compris les tableaux . Ainsi, j’estime nécessaire de signaler une mise en garde particulière.
Dans les tableaux, contrairement aux vieux objets ordinaires, utiliser delete laisse les ordures sous la forme de null, créant ainsi 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 constater, delete ne fonctionne pas toujours comme on pourrait s'y attendre. La valeur est écrasée, mais la mémoire n'est pas réaffectée. C'est-à-dire que array[4] n'est pas déplacé vers array[3]. Ce qui contraste avec 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, en dehors de la définition de null plutôt que de undefined-- qui est légitimement étrange - ce comportement ne devrait pas être surprenant, puisque delete est un opérateur unaire, comme typeof, qui est dur dans le langage et qui n’est pas censé se soucier du type de l'objet sur lequel il est utilisé, alors que Array est une sous-classe de Object avec des méthodes spécialement conçues pour travailler avec des tableaux. Donc, il n'y a pas de bonne raison pour que delete ait un cas spécial pour redistribuer le tableau, car cela ralentirait les choses avec un travail inutile. Rétrospectivement, mes attentes étaient irréalistes.
Bien sûr, cela m'a surpris. Parce que j'ai écrit ceci pour justifier ma croisade contre "null garbage":
Ignorer les dangers et les problèmes inhérents à
null, ainsi que l’espace gaspillé, peut poser problème si le tableau doit être précis.
Ce qui est une justification terrible pour se débarrasser de la nulls --null n’est dangereux que s’il est utilisé à mauvais escient, et cela n’a rien à voir avec la "précision". La vraie raison pour laquelle vous ne devriez pas delete depuis un tableau est que laisser des structures de données désordonnées et désordonnées est une tâche lourde et sujette aux bogues.
Ce qui suit est un scénario artificiel qui prend du temps, vous pouvez donc passer directement à la section, La solution, si vous le souhaitez. La seule raison pour laquelle je quitte cette section est que je pense que certaines personnes pensent probablement que c'est drôle, et je ne veux pas être "ce type" qui publie une réponse "drôle" et en supprime ensuite tous les "drôle" .
... C'est stupide, je sais.
Le scénario PDP-11 artificiel et long
Par exemple, supposons que vous créez une application Web qui utilise la sérialisation JSON pour stocker un tableau utilisé pour les "onglets" dans une chaîne (dans ce cas,
localStorage). Supposons également que le code utilise les index numériques des membres du tableau pour les "titrer" lors de l'affichage à l'écran. Pourquoi faites-vous cela plutôt que de simplement stocker le "titre"? Parce que ... raisonne .D'accord, disons simplement que vous essayez d'économiser de la mémoire à la demande de cet utilisateur qui exécute un mini-ordinateur PDP-11 des années 1960 sous UNIX et a écrit son propre navigateur convivial pour les imprimantes, compatible avec JavaScript et basé sur Elinks, car X11 est hors de question .
Mis à part le scénario de cas Edge de plus en plus stupide, l'utilisation de
deletesur ledit tableau aura pour résultat quenullpollue le tableau et provoque probablement des bugs dans l'application ultérieurement. Et si vous vérifieznull, il sautera directement les nombres et les onglets seront rendus comme[1] [2] [4] [5] ....if (array[index] == null) continue; else title = (index + 1).toString(); /* 0 -> "1" * 1 -> "2" * 2 -> (nothing) * 3 -> "4" */Oui, ce n'est certainement pas ce que tu voulais.
Maintenant, vous pourriez conserver un deuxième itérateur, comme
j, pour ne l'incrémenter que lorsque des valeurs valides sont lues dans le tableau. Mais cela ne résoudrait pas exactement le problèmenull, et vous devez toujours faire plaisir à ce quetrollPDP-11 utilisateur. Hélas, son ordinateur ne possède pas assez de mémoire pour contenir le dernier entier (ne demandez pas comment il parvient à gérer un tableau de largeur variable ...).Alors, il vous envoie un email en 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À propos de maintenant, vous êtes à la fin de votre esprit. Ce mec se plaint sans cesse de votre application et vous voulez lui dire de se taire et d'aller chercher un meilleur ordinateur.
La solution: Array.prototype.splice
Heureusement, les tableaux ont une méthode spécialisée pour supprimer des index et réaffecter de la mémoire: Array.prototype.splice(). Vous pourriez é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 avez satisfait M. PDP-11. Hourra! (Je lui dis toujours quand même ...)
Array.prototype.splice vs Array.prototype.slice
Je pense qu'il est important de souligner la différence entre ces deux fonctions portant le même nom, car elles sont toutes deux très utiles.
Array.prototype.splice (début, n)
.splice() modifie le tableau et renvoie les index supprimés. Le tableau est découpé à partir de l'index, les éléments start et n sont découpés. Si n n'est pas spécifié, le tableau entier après start est découpé en tranches (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 (début, fin)
.slice() est non destructif et renvoie un nouveau tableau contenant les index indiqués de start à end. Si end n'est pas spécifié, le comportement est le même que .splice() (end = array.length). Le comportement est un peu délicat car, pour une raison quelconque, end indexe de 1 au lieu de 0. Je ne sais pas pourquoi il fait cela, mais c'est comme ça. De plus, 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 en fait pas ce qui se passe, mais il est plus facile de penser de cette façon. Selon MDN, voici ce qui se passe réellement:
// 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'indice spécifié par end est simplement exclu de la tranche. Les index entre parenthèses indiquent ce qui doit être découpé. Quoi qu'il en soit, le comportement n'est pas intuitif et il est voué à son lot d'erreurs différentes. Il peut donc être utile de créer une fonction wrapper pour imiter de plus près 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);
}
Notez que la fonction wrapper est conçue pour être très stricte à propos des types, et retournera null si quelque chose est désactivé. Cela inclut la mise dans une chaîne comme "3". Il appartient au programmeur de faire preuve de diligence à propos de ses types. Ceci est d'encourager de bonnes pratiques de programmation.
Mise à jour concernant is_array()
Ceci concerne cet extrait (maintenant supprimé):
function is_array(array){
return array !== null
&& typeof array === "object"
&& typeof array.length !== "undefined"
&& array.__proto__ === Array.prototype;
}
Donc, en fait, il y a en fait IS un moyen intégré d'indiquer si un tableau est vraiment un tableau, et il s'agit de Array.isArray(), introduit dans ECMAScript 5 (décembre 2009). J'ai trouvé cela en cherchant à savoir s'il y avait une question concernant la distinction entre les tableaux et les objets, pour voir s'il existait une solution meilleure que la mienne, ou pour ajouter la mienne s'il n'y en avait pas. Ainsi, si vous utilisez une version de JavaScript antérieure à ECMA 5, vous disposez de votre polyfill. Cependant, je déconseille vivement d'utiliser ma fonction is_array(), car continuer à prendre en charge les anciennes versions de JavaScript signifie continuer à prendre en charge les anciens navigateurs qui les implémentent, ce qui signifie encourager l'utilisation de logiciels non sécurisés et exposer les utilisateurs aux logiciels malveillants. Alors s'il vous plaît, utilisez Array.isArray(). Utilisez let et const. Utilisez les nouvelles fonctionnalités ajoutées à la langue. N'utilisez pas les préfixes de fournisseur. Supprimez ce IE merde polyfill de votre site Web. Supprimez cette merde <!CDATA[[... XHTML - nous sommes également passés à HTML5 en 2014. Plus tôt tout le monde annulera la prise en charge de ces anciens navigateurs/ésotériques, plus tôt les éditeurs de navigateurs suivront la norme Web et adopteront la nouvelle technologie, et plus vite nous pourrons passer à un site Web plus sécurisé.
Vieille question, réponse moderne. En utilisant la déstructuration d'objet, une fonctionnalité ECMAScript 6 , c'est aussi simple que:
const { a, ...rest } = { a: 1, b: 2, c: 3 };
Ou avec l'échantillon de questions:
const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);
Vous pouvez le voir en action dans l'éditeur d'essais de Babel.
Modifier:
Pour réaffecter la même variable, utilisez un let:
let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);
Une autre alternative consiste à utiliser la bibliothèque nderscore.js .
Notez que _.pick() et _.omit() renvoient tous deux une copie de l'objet et ne modifient pas directement l'objet d'origine. Assigner le résultat à l'objet d'origine devrait faire l'affaire (non illustré).
Référence: lien _. Pick (objet, * clés)
Retourne une copie de l'objet, filtrée pour n'avoir que des valeurs pour les clés de la liste blanche (ou le 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 _. Omit (objet, * clés)
Retourne une copie de l'objet, filtrée pour omettre les clés en liste noire (ou le tableau de clés).
var myJSONObject =
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};
Pour les tableaux, _.filter() et _.reject() peuvent être utilisés de la même manière.
Syntaxe de propagation (ES6)
A qui en a besoin ...
Pour compléter la réponse @Koen dans ce fil de discussion, si vous souhaitez supprimer une variable dynamique à l'aide de la syntaxe spread, procédez comme suit:
const key = 'a';
const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };
console.log(rest); // { b: 2, c: 3 }
* foo sera une nouvelle variable avec la valeur de a (qui est 1).
UPDATE:
Il existe peu de moyens courants de supprimer une propriété d'un objet.
Chacun a ses avantages et ses inconvénients ( cochez cette comparaison de performances ):
Opérateur de suppression
Lisible et concis, cependant, ce n'est peut-être pas le meilleur choix si vous travaillez sur un grand nombre d'objets, car ses performances ne sont pas optimisées.
delete obj[key];
Réattribution
Plus de 2 fois plus rapide que delete, la propriété est non supprimée et peut être itérée.
obj[key] = null;
obj[key] = false;
obj[key] = undefined;
Opérateur d'épandage
Cet opérateur ES6 nous permet de renvoyer un nouvel objet, à l'exclusion des propriétés, sans modifier l'objet existant. L'inconvénient est que ses performances sont pires que celles mentionnées ci-dessus et qu'il n'est pas recommandé de les utiliser lorsque vous devez supprimer plusieurs propriétés à la fois.
{ [key]: val, ...rest } = obj;
Le terme que vous avez utilisé dans le titre de votre question Remove a property from a JavaScript object peut être interprété de différentes manières. L’une consiste à l’enlever pour l’ensemble de la mémoire et la liste des clés d’objet ou l’autre à l’enlever de votre objet. Comme il a été mentionné dans d'autres réponses, le mot clé delete constitue la partie principale. Disons que vous avez votre objet comme:
myJSONObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
Si tu fais:
console.log(Object.keys(myJSONObject));
le résultat serait:
["ircEvent", "method", "regex"]
Vous pouvez supprimer cette clé spécifique de vos clés d’objet comme suit:
delete myJSONObject["regex"];
Ensuite, la clé de votre objet utilisant Object.keys(myJSONObject) serait:
["ircEvent", "method"]
Mais le fait est que si vous vous souciez de la mémoire et que vous voulez que tout l'objet soit supprimé de la mémoire, il est recommandé de le définir sur null avant de supprimer la clé:
myJSONObject["regex"] = null;
delete myJSONObject["regex"];
L'autre point important ici est de faire attention à vos autres références au même objet. Par exemple, si vous créez une variable comme:
var regex = myJSONObject["regex"];
Ou ajoutez-le comme un nouveau pointeur sur un autre objet tel que:
var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];
Ensuite, même si vous le supprimez de votre objet myJSONObject, cet objet spécifique ne sera pas supprimé de la mémoire car les variables regex et myOtherObject["regex"] ont toujours leurs valeurs. Alors, comment pourrions-nous supprimer l'objet de la mémoire à coup sûr?
La réponse serait de supprimer toutes les références que vous avez dans votre code, pointé sur cet objet même et aussi non utilisez les instructions var pour créer de nouvelles références à cet objet . Ce dernier point concernant les instructions var est l’un des problèmes les plus cruciaux auquel nous sommes généralement confrontés, car l’utilisation des instructions var empêcherait l’objet créé de ne pas être supprimé.
Cela signifie que dans ce cas, vous ne pourrez pas supprimer cet objet car vous avez créé la variable regex via une instruction var. Si vous le faites:
delete regex; //False
Le résultat serait false, ce qui signifie que votre instruction de suppression n'a pas été exécutée comme prévu. Mais si vous n'aviez pas créé cette variable auparavant et que vous n'aviez que myOtherObject["regex"] comme dernière référence existante, vous auriez pu le faire en le supprimant simplement comme suit:
myOtherObject["regex"] = null;
delete myOtherObject["regex"];
En d'autres termes, un objet JavaScript est tué dès qu'il ne reste aucune référence dans votre code pointant sur cet objet.
Mise à jour: Merci à @AgentME:
Définir une propriété sur null avant de la supprimer n'apporte rien (sauf si l'objet a été scellé par Object.seal et que la suppression échoue. Ce n'est généralement pas le cas, à moins que vous n'essayiez spécifiquement).
Pour obtenir plus d'informations sur Object.seal: Object.seal ()
ECMAScript 2015 (ou ES6) est venu avec un objet Reflect intégré. Il est possible de supprimer la propriété d'un objet en appelant la fonction Reflect.deleteProperty () avec l'objet cible et la clé de propriété comme paramètres:
Reflect.deleteProperty(myJSONObject, 'regex');
qui équivaut à:
delete myJSONObject['regex'];
Mais si la propriété de l'objet n'est pas configurable, elle ne peut être supprimée ni avec la fonction deleteProperty ni avec l'opérateur delete:
let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value
Object.freeze () rend toutes les propriétés de l'objet non configurables (à part d'autres choses). La fonction deleteProperty (ainsi que opérateur de suppression ) renvoie false lorsque vous tentez de supprimer l'une de ses propriétés. Si la propriété est configurable, elle retourne true, même si la propriété n'existe pas.
La différence entre delete et deleteProperty est lorsque vous utilisez le mode strict:
"use strict";
let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted
Supposons que vous ayez 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',
...
]
};
Suppression d'une propriété d'objet
Si vous voulez utiliser tout le tableau staff, la bonne façon de procéder est la suivante:
delete Hogwarts.staff;
Alternativement, vous pouvez aussi faire ceci:
delete Hogwarts['staff'];
De même, la suppression du tableau des étudiants dans son intégralité serait effectuée en appelant delete Hogwarts.students; ou delete Hogwarts['students'];.
Suppression d'un index de tableau
Désormais, si vous souhaitez supprimer un seul membre du personnel ou un étudiant, la procédure est un peu différente, car les deux propriétés sont des tableaux eux-mêmes.
Si vous connaissez l'index de votre membre du personnel, vous pouvez simplement faire ceci:
Hogwarts.staff.splice(3, 1);
Si vous ne connaissez pas l'index, vous devrez également effectuer une recherche dans l'index:
Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);
Remarque
Bien que vous puissiez techniquement utiliser delete pour un tableau, son utilisation donnerait des résultats incorrects lors de l'appel ultérieur, par exemple Hogwarts.staff.length. En d'autres termes, delete supprime l'élément, mais ne met pas à jour la valeur de la propriété length. L'utilisation de delete perturberait également votre indexation.
Ainsi, lors de la suppression de valeurs d'un objet, commencez toujours par déterminer s'il s'agit de propriétés d'objet ou de valeurs de tableau, puis choisissez la stratégie appropriée en fonction de celle-ci.
Si vous voulez expérimenter cela, vous pouvez utiliser ce violon comme point de départ.
Le opérateur de suppression est le meilleur moyen de le faire.
Un exemple en direct à montrer:
var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
Personnellement, j'utilise nderscore.js ou Lodash pour la manipulation d'objets et de tableaux:
myObject = _.omit(myObject, 'regex');
Utilisation de ES6:
(Opérateur Destructuring + Spread)
const myObject = {
regex: "^http://.*",
b: 2,
c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }
Utiliser la méthode delete est le meilleur moyen de le faire. Selon la description du MDN, l'opérateur de suppression supprime une propriété d'un objet. Donc, vous pouvez simplement écrire:
delete myObject.regex;
// OR
delete myObject['regex'];
L'opérateur delete supprime une propriété donnée d'un objet. En cas de suppression réussie, il retournera vrai, sinon faux sera renvoyé. Cependant, il est important d’envisager les scénarios suivants:
Si la propriété que vous essayez de supprimer n'existe pas, la suppression n'aura aucun effet et renverra true
Si une propriété portant le même nom existe dans la chaîne de prototypes de l'objet, après sa suppression, celui-ci utilisera la propriété de la chaîne de prototypes (en d'autres termes, la suppression n'a d'effet que sur ses propres propriétés).
Toute propriété déclarée avec var ne peut pas être supprimée de la portée globale ou de la portée d'une fonction.
En tant que tel, delete ne peut supprimer aucune fonction de la portée globale (qu'elle fasse partie d'une définition de fonction ou d'une fonction (expression).
Fonctions qui font partie d’un objet (en dehors de la
portée globale) peuvent être supprimés avec delete.Toute propriété déclarée avec let ou const ne peut pas être supprimée de la portée dans laquelle elles ont été définies. Les propriétés non configurables ne peuvent pas être supprimées. Cela inclut les propriétés des objets intégrés tels que Math, Array, Object et les propriétés créées de manière non configurable avec des méthodes telles que Object.defineProperty ().
L'extrait suivant donne un autre exemple simple:
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 truePour plus d'informations et voir plus d'exemples, visitez le lien ci-dessous:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete
Une autre solution, en utilisant Array#reduce.
_var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
myObject = Object.keys(myObject).reduce(function(obj, key) {
if (key != "regex") { //key you want to remove
obj[key] = myObject[key];
}
return obj;
}, {});
console.log(myObject);_Cependant, il va muter l'objet d'origine. Si vous souhaitez créer un nouvel objet sans la clé spécifiée, affectez simplement la fonction de réduction à une nouvelle variable, par exemple:
(ES6)
_const myObject = {
ircEvent: 'PRIVMSG',
method: 'newURI',
regex: '^http://.*',
};
const myNewObject = Object.keys(myObject).reduce((obj, key) => {
key !== 'regex' ? obj[key] = myObject[key] : null;
return obj;
}, {});
console.log(myNewObject);_Ce message est très ancien et je le trouve très utile; j'ai donc décidé de partager la fonction non définie que j'ai écrite au cas où quelqu'un d'autre verrait ce message et se demanderait pourquoi ce n'est pas si simple comme cela dans PHP fonction non définie.
La raison d’écrire cette nouvelle fonction unset est de conserver l’index de toutes les autres variables dans ce hash_map. Examinez l'exemple suivant et voyez comment l'index de "test2" n'a pas changé après la suppression d'une valeur de hash_map.
function unset(unsetKey, unsetArr, resort){
var tempArr = unsetArr;
var unsetArr = {};
delete tempArr[unsetKey];
if(resort){
j = -1;
}
for(i in tempArr){
if(typeof(tempArr[i]) !== 'undefined'){
if(resort){
j++;
}else{
j = i;
}
unsetArr[j] = tempArr[i];
}
}
return unsetArr;
}
var unsetArr = ['test','deletedString','test2'];
console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}
Il y a beaucoup de bonnes réponses ici, mais je voudrais juste dire que lorsque vous utilisez delete pour supprimer une propriété en JavaScript, il est souvent sage de vérifier d'abord si cette propriété existe pour éviter les erreurs.
Par exemple
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 arrive souvent que vous ne sachiez tout simplement pas si la propriété existe ou non. En vérifiant si obj existe avant le &&, vous vous assurez également de ne pas générer d'erreur en appelant la fonction hasOwnProperty () sur un objet non défini.
Désolé si cela n’ajoute rien à votre cas d’utilisation spécifique, mais j’estime qu’il s’agit d’une bonne conception à adapter lors de la gestion des objets et de leurs propriétés.
Pour cloner un objet sans propriété:
Par exemple:
let object = { a: 1, b: 2, c: 3 };
Et nous devons supprimer "a".
1.avec clé prop explicite:
const { a, ...rest } = object;
object = rest;
2.Avec la clé de prop variable:
const propKey = 'a';
const { [propKey]: propValue, ...rest } = object;
object = rest;
Fonction de flèche 3.Cool ????:
const removePropery = (propKey, { [propKey]: propValue, ...rest }) => rest;
object = removePropery('a', object);
4. Pour plusieurs 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 }
En utilisant ramda # dissoc , vous obtiendrez un nouvel objet sans l’attribut regex:
const newObject = R.dissoc('regex', myObject);
// newObject !== myObject
Vous pouvez également utiliser d'autres fonctions pour obtenir le même effet - omettre, choisir, ...
Essayez la méthode suivante. Affectez la valeur de la propriété Object à undefined. Ensuite, stringify l'objet et parse.
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));
console.log(myObject);Si vous souhaitez supprimer une propriété profondément imbriquée dans l'objet, vous pouvez utiliser la fonction récursive suivante avec chemin d'accès à la propriété comme second argument:
var deepObjectRemove = function(obj, path_to_key){
if(path_to_key.length === 1){
delete obj[path_to_key[0]];
return true;
}else{
if(obj[path_to_key[0]])
return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));
else
return false;
}
};
Exemple:
var a = {
level1:{
level2:{
level3: {
level4: "yolo"
}
}
}
};
deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);
//Prints {level1: {level2: {}}}
Vous pouvez simplement supprimer n'importe quelle propriété d'un objet à l'aide du mot clé delete.
Par exemple:
var obj = {key1:"val1",key2:"val2",key3:"val3"}
Pour supprimer une propriété, dites key1, utilisez le mot clé delete de la manière suivante:
delete obj.key1
Ou vous pouvez également utiliser une notation de type tableau:
delete obj[key1]
Réf.: MDN .
Pensez à créer un nouvel objet sans la propriété "regex", car l'objet d'origine pourrait toujours être référencé par d'autres parties de votre programme. Ainsi, vous devriez éviter de le manipuler.
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const { regex, ...newMyObject } = myObject;
console.log(newMyObject);const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const { regex, ...other } = myObject;
console.log(myObject)
console.log(regex)
console.log(other)L'affirmation de Dan selon laquelle "supprimer" est très lente et le point de repère qu'il a publié ont été mis en doute. J'ai donc effectué le test moi-même sous Chrome 59. Il semble que "supprimer" soit environ 30 fois plus lent:
var iterationsTotal = 10000000; // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i<iterationsTotal; i++) {
o = {a:1,b:2,c:3,d:4,e:5};
delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;
}
console.log ((t2=Date.now())-t1); // 6135
for (let i=0; i<iterationsTotal; i++) {
o = {a:1,b:2,c:3,d:4,e:5};
o.a = o.b = o.c = o.d = o.e = undefined;
}
console.log (Date.now()-t2); // 205
Notez que j'ai volontairement effectué plus d'une opération de "suppression" dans un cycle de boucle afin de minimiser l'effet provoqué par les autres opérations.
Object.assign () et Object.keys () et Array.map ()
const obj = {
"Filters":[
{
"FilterType":"between",
"Field":"BasicInformationRow.A0",
"MaxValue":"2017-10-01",
"MinValue":"2017-09-01",
"Value":"Filters value"
}
]
};
let new_obj1 = Object.assign({}, obj.Filters[0]);
let new_obj2 = Object.assign({}, obj.Filters[0]);
/*
// old version
let shaped_obj1 = Object.keys(new_obj1).map(
(key, index) => {
switch (key) {
case "MaxValue":
delete new_obj1["MaxValue"];
break;
case "MinValue":
delete new_obj1["MinValue"];
break;
}
return new_obj1;
}
)[0];
let shaped_obj2 = Object.keys(new_obj2).map(
(key, index) => {
if(key === "Value"){
delete new_obj2["Value"];
}
return new_obj2;
}
)[0];
*/
// new version!
let shaped_obj1 = Object.keys(new_obj1).forEach(
(key, index) => {
switch (key) {
case "MaxValue":
delete new_obj1["MaxValue"];
break;
case "MinValue":
delete new_obj1["MinValue"];
break;
default:
break;
}
}
);
let shaped_obj2 = Object.keys(new_obj2).forEach(
(key, index) => {
if(key === "Value"){
delete new_obj2["Value"];
}
}
);Enlèvement de propriété en JavaScript
Cette page propose de nombreuses options différentes, non pas parce que la plupart d'entre elles sont erronées (ou parce que les réponses sont des doublons), mais parce que la technique appropriée dépend de la situation dans laquelle vous vous trouvez et des objectifs des tâches que vous et/ou vous avez. l'équipe essaie de remplir. Pour répondre à votre question sans équivoque, il faut savoir:
- La version d'ECMAScript que vous ciblez
- La gamme de types d'objet sur lesquels vous souhaitez supprimer des propriétés et le type de noms de propriété que vous devez pouvoir omettre (chaînes uniquement? Symboles?? Références faibles mappées à partir d'objets arbitraires? Ces types de pointeurs de propriétés sont en JavaScript depuis des années maintenant. )
- L'éthique/les schémas de programmation que vous et votre équipe utilisez. Préférez-vous les approches fonctionnelles et la mutation est-elle verbotée sur votre équipe, ou utilisez-vous des techniques orientées objet mutatives de type far west?
- Souhaitez-vous atteindre cet objectif en JavaScript pur ou souhaitez-vous utiliser une bibliothèque tierce?
Une fois que ces quatre requêtes ont été traitées, il existe essentiellement quatre catégories de "suppression de propriété" en JavaScript parmi lesquelles choisir afin de répondre à vos objectifs. Elles sont:
Suppression de propriété d'objet mutatif, non sécurisée
Cette catégorie permet d'opérer sur des littéraux d'objet ou des instances d'objet lorsque vous souhaitez conserver/continuer à utiliser la référence d'origine et que vous n'utilisez pas les principes fonctionnels sans état dans votre code. Un exemple 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 catégorie la plus ancienne, la plus directe et la plus largement prise en charge de la suppression de propriétés. Il supporte les index Symbol & array en plus des chaînes et fonctionne dans toutes les versions de JavaScript, à l'exception de la toute première version. Cependant, c'est la mutation qui viole certains principes de programmation et a des implications sur les performances. Cela peut également entraîner des exceptions non capturées lorsqu'il est utilisé sur propriétés non configurables en mode strict .
Omission de propriété de chaîne basée sur le repos
Cette catégorie est destinée aux opérations sur des instances d'objet ou de tableau simples dans les nouvelles versions ECMAScript lorsqu'une approche non mutante est souhaitée et que vous n'avez pas besoin de prendre en compte les clés Symbol:
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 :(
Suppression de propriété d'objet mutatif, sûr
Cette catégorie permet d'opérer sur des littéraux d'objet ou des instances d'objet lorsque vous souhaitez conserver/continuer à utiliser la référence d'origine tout en évitant que des exceptions ne soient générées sur des propriétés non configurables:
'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
De plus, bien que la mutation d'objets sur place ne soit pas sans état, vous pouvez utiliser la nature fonctionnelle de Reflect.deleteProperty pour effectuer une application partielle et d'autres techniques fonctionnelles impossibles avec les instructions delete.
Omission de propriété de chaîne basée sur la syntaxe
Cette catégorie est destinée aux opérations sur des instances d'objet ou de tableau simples dans les nouvelles versions ECMAScript lorsqu'une approche non mutante est souhaitée et que vous n'avez pas besoin de prendre en compte les clés Symbol:
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 :(
Omission de propriété basée sur une bibliothèque
Cette catégorie permet généralement une plus grande flexibilité fonctionnelle, notamment la comptabilisation des symboles et l’omission de plusieurs propriétés dans un seul énoncé:
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"
Essaye ça
delete myObject['key'];
Bonjour vous pouvez essayer cette simple une sorte
var obj = [];
obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};
delete(obj.key1);
Utiliser lodash
import omit from 'lodash/omit';
const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');
Utiliser Ramda
R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
Vous pouvez utiliser la déstructuration ES6 avec l'opérateur de repos.
Les propriétés peuvent être supprimées à l'aide de déstructuration en combinaison avec opérateur de repos. Dans votre exemple, l'expression rationnelle est déstructurée (ignorée) et les autres propriétés sont renvoyées en tant que reste.
const noRegex = ({ regex, ...rest }) => rest;
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
console.log(noRegex(myObjext)) //=> { "ircEvent": "PRIVMSG","method": "newURI" }
Ou vous pouvez exclure dynamiquement des propriétés comme celle-ci,
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest
const removeRegex = removeProperty('regex') //=> { "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> { "ircEvent": "PRIVMSG", "regex":"^http://.*" }
@ johnstock, nous pouvons également utiliser le concept de prototypage de JavaScript pour ajouter une méthode aux objets afin de supprimer toute clé passée disponible dans l'objet appelant.
Les réponses ci-dessus sont appréciées.
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 }
Très simple:
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
delete myObject.regex;
vous pouvez utiliser l'opérateur delete à partir de ci-dessous.
var multiverse = {
earth1: "Silver Age",
earth2: "Golden Age"
};
delete multiverse.earth2;//will return true if it finds
// Outputs: { earth1: "Silver Age" }
console.log(multiverse);
L'opérateur de suppression a également un return value. S'il parvient à supprimer une propriété, il renvoie true. S'il ne parvient pas à supprimer une propriété, car celle-ci est non lisible, elle sera return false ou, si elle est en mode strict, une erreur est générée.
Comme beaucoup l'ont déjà dit, vous pouvez utiliser "delete" (propriété javascript) ou "unset" (en utilisant lodash).
Vous pouvez également utiliser la propriété lodash "pick" pour ne sélectionner que les propriétés d'objet nécessaires. Cela vous aidera lorsque vous pourrez supprimer 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}
J'ai utilisé lodash "unset" pour que cela se produise également pour un objet imbriqué .. seulement ce besoin d'écrire une petite logique pour obtenir le chemin de la clé de propriété attendu par la méthode omit.
- Méthode qui retourne la propriété path en tant que tableau
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"))<div id="output">
</div>- Ensuite, il suffit d'utiliser lodash unset method remove property from object.
var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));function removeProperty(obj, prop) {
if(prop in obj){
Reflect.deleteProperty(obj, prop);
return true;
} else {
return false;
}
}
For
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
supprimer monObjet ["regex"]; Aussi, vous connaissez l'index de la clé, par exemple. Vous devez supprimer la 2ème clé (regex) puis
var key = Object.keys(myObject)[2]
delete myObject[key];
Plusieurs fois, nous avons besoin de la suppression basée sur un index dans un objet, mais les clés Remember dans un objet peuvent être positionnées de haut en bas, donc soyez prudent lors de son utilisation.