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

question créée à Sun, Feb 19, 2017 12:00 AM

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"
};
    
5583
  1. Trouvez ici un point de repère qui compare "delete" vs "undefined" vs "null" jsben.ch /# /BWMiw
    2017-03-06 11: 31: 56Z
  2. 2017-11-15 15: 35: 26Z
30 réponses                              30                         

Comme ceci:

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

Si vous souhaitez en savoir plus à ce sujet, l’utilisateur kangax de Stack Overflow a écrit un article de blog incroyablement détaillé sur la déclaration delete sur leur blog, Comprendre la suppression . C'est fortement recommandé.

    
7655
2017-10-09 16: 55: 56Z
  1. Cochée, cela fonctionne aussi avec "delete myJSONObject ['regex'];" Voir: developer.mozilla.org/en/Core_JavaScript_1.5_Reference/…
    2008-10-16 11: 06: 42Z
  2. Un résultat de l'une des observations sur le lien "comprendre la suppression" ci-dessus est que, puisque vous ne pouvez pas nécessairement supprimer une variable, mais uniquement les propriétés de l'objet, vous ne pouvez donc pas supprimer une propriété d'objet "par référence" - var value = obj ['prop']; supprimer la valeur //ne fonctionne pas
    2010-04-16 16: 24: 33Z
  3. Donc, il ne le supprime pas réellement? Cela devient juste indéfini, mais la clé existe toujours? Est-ce que je manque quelque chose?
    2011-08-10 02: 21: 35Z
  4. @ Pete non, cela le supprime. Donné: var x = {a : 'A', b : 'B'}; Comparer: delete x.a; typeof x.a; /* "undefined" */ x.hasOwnProperty('a'); /* false */ à x.b = undefined; typeof x.b; /* "undefined" */; x.hasOwnProperty('b'); /* true */
    2011-08-10 08: 29: 19Z
  5. @ ChristopherPfohl travaille pour moi. Comme je l'ai dit, c'est en fait assez approfondi, donc c'est un peu difficile à résumer. La réponse de base dans la réponse ci-dessus est suffisante dans presque tous les cas, le blog décrit plus en détail les cas extrêmes et les raisons pour lesquelles ces cas existent.
    2012-12-20 01: 57: 12Z

L'opérateur delete est inopinément lent!

Consultez le référence .

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", réglage 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.

Quandfaut-il utiliser delete et quand la valeur est 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 de résultat au code sur lequel vous n'avez pas le contrôle (ou lorsque vous n'êtes pas sûr 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 paramètre undefined, lorsque vous vous souciez des performances. Cela peut donner un sérieux coup de pouce à votre code.

La touche reste à sa place dans la table de hachage , seule la valeur est remplacée par undefined. Comprenez bien que cette boucle for..in itérera toujours sur cette clé.

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

À l'aide de cette méthode, toutes les méthodes de détermination de l'existence d'une propriété fonctionnera comme prévu.

Cependant, ce code:

object.field === undefined

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

Tests

En résumé, les différences concernent toutes les manières de déterminer l’existence de la propriété et environ for..in en 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. *');

Attention aux fuites de mémoire!

Bien que l’utilisation de obj[prop] = undefined soit plus rapide que celle de delete obj[prop], il est également important de noter que obj[prop] = undefined peut 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, ce qui laisse prop encore 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 de mémoire insuffisante. 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, effectuer simplement une opération 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 paramétrés que sur non défini, 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 d'insuffisance de mémoire, essayez de l'exécuter à nouveau, sauf avec la version suivante du code qui utilise l'opérateur delete à 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 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 en parler 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 ainsi ne pas perdre votre heure à disséquer votre code 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 types différents à la même variable /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, les tableaux polymorphes posent deux problèmes non résolus:

  1. Ils sont lents & 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.
  2. 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 très 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 avec un voyage lié à la 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

Observez. bar[1] = "" ne contraint pas le polymorphisme alors que bar[1] = undefined le fait. Par conséquent, il faut toujours, chaque fois que possible, utiliser le type correspondant à leurs objetsNe pas causer accidentellement un 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 false ou undefined comme 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 un jugement commun!
  • Lorsque vous utilisez un tableau /une variable typée dans la primitive numérique, utilisez 0 comme 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 ceux comprenant NaN et Infinity). 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 à jour l'ancien code vers cette nouvelle pratique. aussi risqué que gratifiant.

    
826
2018-04-19 10: 26: 30Z
  1. une propriété affectée à undefined est toujours une propriété d'un objet; elle ne sera donc pas supprimée par GC, à moins que le dernier paragraphe ne soit mal interprété.
    2014-03-04 21: 05: 54Z
  2. J'ai eu tort de toucher le thème de GC ici. Les deux méthodes ont le même résultat pour GC: elles suppriment la valeur liée à la clé. Si cette valeur était la dernière référence à un autre objet, cet objet serait nettoyé.
    2014-03-06 10: 28: 46Z
  3. une propriété affectée à undefined est toujours une propriété d'un objet, elle ne sera donc pas supprimée par le GC Le GC ne gère pas rien sur les propriétés. Il collecte et supprime les valeurs. Tant que rien ne fait plus référence à une valeur (un objet, une chaîne, etc.), le CPG la supprime de la mémoire.
    2014-07-16 15: 03: 18Z
  4. BTW, c’est le double problème pour vérifier si une propriété existe sur un objet Javascript. Utiliser dans est l’opérateur fiable mais lent. Vérifiez si la propriété n’est pas non définie "n’est pas la bonne réponse" mais c’est beaucoup plus rapide. vérifier
    2014-11-03 17: 32: 30Z
  5. Cette réponse est-elle toujours pertinente? jsperf est actuellement en panne, mais cette référence semble indiquer que la différence de vitesse est de seulement 25%, ce qui n’est nulle part proche du "~ 100 fois plus lent" dans cette réponse.
    2016-12-14 08: 29: 46Z

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

console.log ( myObject.regex); // logs: undefined

Cela fonctionne dans Firefox et Internet Explorer, et je pense que cela fonctionne dans tous les autres.

    
224
2018-06-01 16: 29: 50Z

Mise à jour 2018-07-21: Cela fait longtemps que je suis gêné par cette réponse. Je pense donc qu'il est temps que je retouche un peu. Juste un petit commentaire, des éclaircissements 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 du 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 LONGUE VERSION

JavaScript est un langage POO, donc tout est un objet, y compris les tableaux . C’est pourquoi j’estime nécessaire de signaler une mise en garde particulière.

Dans les tableaux, contrairement aux vieux objets ordinaires, utiliser delete laisse des déchets sous la forme 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 prévu. 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 est différent de 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, mis à part la définition de null plutôt que de undefined - ce qui est légitimement étrange - ce comportement ne devrait pas être surprenant, puisque delete est un opérateur unaire, comme typeof, ce qui est difficile- elle est dans le langage et n'est pas censée se préoccuper 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 fonctionner avec des tableaux. Il n’ya donc aucune raison pour delete d’avoir 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":

  

Ignorant les dangers et les problèmes inhérents à null, ainsi que l’espace perdu, cela peut poser problème si le tableau doit être précis.

Ce qui est une justification terrible pour se débarrasser du null. Le null n’est dangereux que s’il est utilisé à mauvais escient, et cela n’a rien à voir avec la "précision". La véritable raison pour laquelle vous ne devriez pas utiliser delete dans un tableau est que laisser des structures de données désordonnées et désordonnées est lâche et sujet 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 à longue durée

  

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 ... raisons .

     

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 datant des années 1960 sous UNIX et a écrit sa propre base Elinks, Navigateur compatible avec JavaScript et compatible avec les imprimantes, car X11 est hors de question .

     

En dehors du scénario de plus en plus stupide, utiliser delete sur ledit tableau aura pour conséquence que null polluera le tableau et causera probablement des bogues dans l'application plus tard. Et si vous vérifiez null, il sautera directement les nombres, ce qui rendra les onglets 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 vous vouliez.

     

Vous pouvez maintenant conserver un deuxième itérateur, tel que j, pour incrémenter uniquement lorsque des valeurs valides sont lues dans le tableau. Mais cela ne résoudrait pas exactement le problème null, et vous devez quand même plaire à cet utilisateur de troll . Hélas, son ordinateur ne dispose pas de la mémoire nécessaire pour conserver 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’obtenir un meilleur ordinateur.

La solution: Array.prototype.splice

Heureusement, les tableaux ont une méthode spécialisée pour supprimer les index et réaffecter la mémoire: Array.prototype.splice(). Tu pourrais écrirequelque 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 fait plaisir à M. PDP-11. Hourra! (je lui dirais 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 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 le sont. Si n n'est pas spécifié, l'ensemble du tableau 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 indices 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 indexes de 1 au lieu de 0. Je ne sais pas pourquoi il le fait, 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 pas ce qui se passe, mais c’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'index 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 plus fidèlement 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 concernant les types et renverra 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. C’est pour encourager les bonnes pratiques de programmation.

Mise à jour concernant is_array()

Il s’agit de cet extrait (maintenant supprimé):

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

En définitive, il existe donc un moyen intégré de déterminer si un tableau est vraiment un tableau. Il s'agit de Array.isArray(), introduit dans ECMAScript 5 (décembre 2009). J'ai trouvé ceci en cherchant à voir 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 fortement 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 à des programmes 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 du fournisseur. Supprimez cette merde polyfillaire IE de votre site Web. Supprimez également cette merde XHTML <!CDATA[[... - nous sommes passés à HTML5 en 2014. Plus tôt tout le monde retirera la prise en charge de ces navigateurs anciens /ésotériques, plus tôt les éditeurs de navigateurs suivront la norme Web et adopteront la nouvelle technologie, et plus vite peut passer à un site Web plus sécurisé.

    
182
2019-04-27 03: 47: 41Z
  1. Ce mot clé delete est toutefois beaucoup plus pratique, lol
    2012-09-18 00: 59: 47Z
  2. Cette approche ne modifie pas l'objet d'origine qui pourrait toujours être référencé ailleurs. Cela peut être ou ne pas être un problème en fonction de la façon dont il est utilisé, mais c'est quelque chose à garder à l'esprit.
    2012-11-07 17: 39: 59Z
  3. @ B1KMusic Voici comment supprimer un élément d'un tableau: splice
    2013-01-25 20: 20: 43Z
  4. @ wulftone nope, qui divise le tableau et ne fait rien pour supprimer une valeur. Je pense vraiment que le meilleur moyen de supprimer d’un tableau contenant des valeurs spécifiques est d’utiliser delete et de créer une fonction de nettoyage de place pour le nettoyer.
    2013-01-26 20: 37: 09Z
  5. Je ne vois pas splice dansvotre édition, mais remove doit être Array.prototype.remove = function(index) { this.splice(index, 1); };
    2013-08-27 04: 01: 41Z

Vieille question, réponse moderne. À l'aide de la déstructuration des objets, une fonctionnalité ECMAScript 6 est aussi simple que:

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

Ou avec l'exemple 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’essai 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);
    
147
2016-12-01 20: 51: 19Z
  1. Peut-être parce que l'objectif est de supprimer une propriété d'un objet, pas d'en créer une nouvelle sans la propriété ... bien que votre solution soit ma préférée, car préférez la voie immuable.
    2016-12-01 17: 14: 04Z
  2. La question disait "pour se retrouver avec nouveau monObjet".
    2016-12-01 20: 45: 31Z
  3. Ajouter un trait de soulignement pour supprimer une propriété jettera votre projet :) Au lieu de l'avoir disponible en tant que regex, vous pouvez également l'assigner à une autre variable, par exemple. _, ce qui est utilisé dans des langues comme Aller à ignorer un résultat: const { regex: _, ...newObject } = myObject;.
    2017-06-30 07: 30: 00Z
  4. C'est en fait une douce ligne pour une nouvelle affectation d'objet sans accessoires indésirables, et déjà supportée avec Node.js 8. * /9. * avec --harmony: node.green/…
    2017-07-01 18: 51: 14Z
  5. Avec les objets freeze() 'd et seal()' d, vous ne pouvez pas simplement delete une propriété. C'est donc une excellente alternative. Bien que dans la plupart des cas, il n’est probablement pas judicieux de supprimer une propriété d’un objet gelé /scellé de toute façon, étant donné que l’essentiel est de donner certaines garanties sur vos structures de données, ce que cela nuirait à. Pour les cas où vous devez duper de manière non destructive un objet mais sans certaines de ses propriétés, c'est parfait
    2018-08-03 05: 45: 22Z

Une autre alternative consiste à utiliser la bibliothèque Underscore.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) p>

Retourne une copie de l'objet, filtrée pour n'avoir que des valeurs pour le clés inscrites sur la liste blanche (ou 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) p>

Retourne une copie de l'objet, filtrée pour omettre le Clés sur la liste noire (ou 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 manière similaire.

    
88
2018-02-03 19: 51: 40Z
  1. Gardez à l'esprit que si les clés de votre objet sonte numéros, vous devrez peut-être _.omit(collection, key.toString())
    2014-12-09 01: 32: 19Z
  2. Hmmmmm .... Le trait de soulignement est environ 100 fois plus lent que delete obj[prop], ce qui est environ 100 fois plus lent que obj[prop] = undefined.
    2018-04-14 23: 00: 57Z

Syntaxe de propagation (ES6)

À quiconque 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 a (qui vaut 1).


MISE À JOUR :
Il existe peu de moyens courants de supprimer une propriété d'un objet.
Chacun a ses avantages et ses inconvénients ( vérifiez cette comparaison de performances ):

Opérateur de suppression
Lisible et concis, il 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éaffectation
Plus de 2 fois plus rapide que delete, cependant, la propriété n'est pas supprimée et peut être itérée.

 
obj[key] = null;
obj[key] = false;
obj[key] = undefined;


Spread Opérateur
Cet opérateur ES6 nous permet de renvoyer un nouvel objet, excluant toute propriété, sans modifier l'objet existant. L’inconvénient est qu’elle présente les performances les plus mauvaises de ce qui précède et qu’il n’est pas conseillé de les utiliser lorsque vous devez supprimer plusieurs propriétés à la fois.

 
{ [key]: val, ...rest } = obj;
    
62
2019-04-23 18: 55: 53Z
  1. Je pense que la syntaxe spread /rest pour les littéraux d'objet était uniquement incluse dans ES2018 (ES9), pas dans ES6, même si plusieurs moteurs JS l'avaient déjà implémentée.
    2018-12-02 20: 52: 15Z
  2. @ trincot Il a été introduit pour la première fois en 2014 ( github.com/tc39/proposal-object-rest-spread ) et qu’il s’agit d’une fonctionnalité ES6 (ECMAScript 2015 ou ECMAScript 6th Edition). Cependant, même si je me trompe, je ne pense pas que cela change le contexte de la réponse.
    2018-12-04 21: 56: 09Z
  3. Le lien fait référence à ES6 où la syntaxe de propagation a bien été introduite pour les tableaux, mais elle continue de proposer quelque chose de similaire pour les littéraux d'objet. Cette deuxième partie n'a été intégrée à l'ES9 que si je ne me trompe pas.
    2018-12-05 07: 03: 19Z

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 consiste simplement à 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 vous le faites:

 
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, par exemple:

 
delete myJSONObject["regex"];

Ensuite, la clé de vos objets utilisant Object.keys(myJSONObject) serait:

 
["ircEvent", "method"]

Mais le fait est que si vous vous souciez de la mémoire et que vous souhaitez que 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 àle même objet. Par exemple, si vous créez une variable telle que:

 
var regex = myJSONObject["regex"];

Ou ajoutez-le en tant que 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?

La solution serait de supprimer toutes les références de votre code, de pointer sur cet objet même et de ne pas utiliser les instructions var pour créer de nouvelles références à cet objet . . Ce dernier point concernant les déclarations 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'aboutit pas   quoi que ce soit (sauf si l'objet a été scellé par Object.seal et le   La suppression échoue. Ce n'est généralement pas le cas, sauf si vous avez spécifiquement   essayez).

Pour plus d'informations sur Object.seal: Object .seal ()

    
45
2015-06-02 22: 18: 26Z
  1. Vous avez tort - seuls les objets sont passés par référence en JavaScript. Par conséquent, si la valeur de myJSONObject.regex est une chaîne et que vous l'assignez à un autre objet, l'autre objet a une copie de cette valeur.
    2016-01-10 16: 58: 19Z
  2. Vous avez raison et voici une citation: "faites attention à vos autres références au même objet."
    2016-01-10 17: 34: 48Z

ECMAScript 2015 (ou ES6) est livré avec l’intégré Reflect objet. Il est possible de supprimer une propriété d'objet en appelant Reflect.deleteProperty () fonction> 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 () définit toutes les propriétés de objet non configurable (à part d'autres choses). La fonction deleteProperty (ainsi que opérateur de suppression ) renvoie false lors d'une tentative de supprimer l'une de ses propriétés. Si la propriété est configurable, elle renvoie true, même si la propriété n’existe pas.

La différence entre delete et deleteProperty réside dans l'utilisation du 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
    
38
2016-01-25 17: 22: 10Z
  1. @ Gothdo présente plus d'avantages, notamment lorsque vous devez effectuer des tâches fonctionnelles. Par exemple. vous pouvez assigner une fonction à une variable, passer comme argument ou utiliser les fonctions apply, call, bind ...
    2016-01-10 16: 47: 18Z

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 souhaitez utiliser l'intégralité du tableau staff, procédez comme suit:

 
delete Hogwarts.staff;

Vous pouvez également procéder ainsi:

 
delete Hogwarts['staff'];

De même, la suppression de l'ensemble du tableau des étudiants se ferait en appelant delete Hogwarts.students; ou delete Hogwarts['students'];.

Suppression d'un index de tableau

Désormais, si vous souhaitez supprimer un 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 le faire:

 
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

Même si techniquement vous pouvez utiliser delete pour un tableau, son utilisation donnerait des résultats incorrects lors de l'appel ultérieur de Hogwarts.staff.length, par exemple. En d'autres termes, delete supprimerait l'élément, mais ne mettrait pas à jour la valeur de la propriété length. Utiliser delete gâcherait é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 souhaitez expérimenter cela, vous pouvez utiliser ce violon comme point de départ. .

    
37
2016-11-23 09: 17: 42Z
  1. Je pense que vous devriez toujours utiliser splice sur un tableau au lieu de delete.
    2016-09-22 15: 30: 26Z
  2. @ JoelTrauger: C'est ce que je dis; -)
    2016-11-23 09: 19: 15Z
  3. Oui. Mon commentaire est que delete ne devrait même pas être une chose. C'est le splice que recherchait le PO.
    2016-11-23 21: 59: 56Z
  4. @ JoelTrauger: Comme j'ai essayé de l'expliquer, delete doit être utilisé pour les propriétés de l'objet et splice pour les éléments de tableau.
    2016-11-24 10: 01: 08Z
  5. L'épissure est vraiment lente. Bien que cela devrait être utilisé au lieu de delete sur les tableaux, il serait plus sage de ne pas créer de code centré autour de lui.
    2018-04-14 23: 05: 43Z

L'opérateur delete est le meilleur façon de le faire.

Un exemple en direct à afficher:

 
var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
    
27
2016-02-11 20: 30: 34Z
  1. Il convient de noter que même si l'utilisation de l'opérateur delete est saine pour ce qui concerne garbage collection , il peut être inopinément lent partie pour la même raison.
    2015-05-06 17: 51: 33Z

J'utilise personnellement Underscore.js ou Lodash pour la manipulation d'objets et de tableaux:

 
myObject = _.omit(myObject, 'regex');
    
27
2019-01-21 11: 24: 47Z
La meilleure façon de procéder consiste à

utiliser la méthode supprimer . Selon la description du MDN, l'opérateur de suppression supprime une propriété d'un objet. Vous pouvez donc simplement écrire:

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

L'opérateur delete supprime une propriété donnée d'un objet. Sur   suppression réussie, elle retournera vrai, sinon faux sera retourné.   Cependant, il est important d’envisager les scénarios suivants:

     
  • Si la propriété que vous essayez de supprimer n'existe pas, supprimez-la.   n'aura aucun effet et retournera vrai

  •   
  • Si une propriété du même nom existe sur le prototype de l'objet   chaîne, puis, après la suppression, l’objet utilisera la propriété de la   chaîne prototype (en d’autres termes, la suppression n’a d’effet que sur la   propriétés).

  •   
  • Aucune propriété déclarée avec var ne peut ê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 (à part le fichier   portée globale) peut être supprimé avec delete.

  •   
  • Aucune propriété déclarée avec let ou const ne peut ê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 true

Pour plus d'informations sur et voir plus d'exemples, visitez le lien ci-dessous:

https://developer.mozilla.org /fr-fr /docs /Web /JavaScript /Référence /Opérateurs /delete

    
22
2019-04-16 23: 22: 12Z

Autre solution, utilisez 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 mue 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);
    
20
2017-10-24 09: 58: 51Z

Ce message est très ancien et je le trouve très utile. J'ai donc décidé de partager la fonction unset que j'ai écrite au cas où quelqu'un d'autre verrait ce message et se demanderait pourquoi ce n'est pas aussi simple que cela dans PHP unset.

La raison de l’écriture de cette nouvelle fonction unset est de conserver l’index de toutes les autres variables dans ce hash_map. Regardez 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"}
    
19
2016-11-22 21: 35: 37Z

Il y a beaucoup de bonnes réponses ici, mais je voudrais juste préciser 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.

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 arrive souvent que vous ne sachiez tout simplement pas si la propriété existe ou non. Vérifier si obj existe avant les commandes & & veille également à 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 est judicieux de l'adapter à la gestion des objets et de leurs propriétés.

    
18
2014-09-15 00: 48: 08Z
  1. delete foo.bar fonctionne même si la barre n'existe pas, votre test est donc un peu trop difficile, à mon humble avis.
    2015-06-01 15: 14: 02Z
  2. @ PhiLho qui dépend de l'endroit où vous utilisez JavaScript. Dans Node.js, je pense que cela provoque le blocage de votre serveur.
    2015-06-02 20: 07: 29Z
  3. delete foo.bar; ne lève une exception que si foo est faux, ou si vous êtes en mode strict et que foo est un objet avec une propriété de barre non configurable.
    2015-06-02 21: 28: 10Z
  4. Je ne me souviens pas du problème exact que j'ai rencontré, mais je pense que le problème peut apparaître lorsque foo n'existe pas et que vous essayez de supprimer sa propriété. .
    2015-06-02 22: 20: 12Z
  5. Oui, vous devez tester si foo existe, sinon foo.bar lèvera une exception, mais vous n'avez pas besoin de vérifier l'existence de barre avant de la supprimer. C'est la partie "trop" de mon commentaire. : -)
    2015-06-03 09: 16: 35Z

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 }
    
17
2019-06-06 13: 25: 13Z
  1. Je ne pense pas qu'il s'agisse d'une fonctionnalité de l'ES6, mais uniquement d'une fonctionnalité incluse dans l'ES9.
    2018-12-02 20: 53: 29Z
  2. Oui, j'ai essayé d'exploiter ES6 par étapes simples ...
    2018-12-05 05: 54: 00Z
  3. Donc, en réalité, vous n'utilisez pas ES6, car vous écrivez, mais ES9 ...; -)
    2018-12-05 07: 07: 42Z
  4. Il ne s'agit pas de supprimer une propriété d'un objet, mais de créer un nouvel objet sans cette propriété.
    2019-06-21 08: 18: 59Z

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, ...

    
14
2016-11-28 15: 14: 52Z

Essayez la méthode suivante. Attribuez la valeur de la propriété Object à undefined. Puis 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);
    
13
2016-11-22 22: 12: 14Z
  1. Aussi JSON.parse(JSON.stringify({ ...myObject, regex: undefined }))
    2016-09-25 23: 15: 33Z

Si vous souhaitez supprimer une propriété profondément imbriquée dans l'objet, vous pouvez utiliser la fonction récursive suivante avecchemin d'accès à la propriété en tant que deuxième 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: {}}}
    
11
2016-06-23 09: 38: 58Z
  1. Cette fonction fonctionne comme un charme, mais pourquoi avons-nous besoin de retourner true et de false? Ma version du code: codepen.io/anon/pen/rwbppY . Ma version va-t-elle échouer dans tous les cas?
    2017-07-17 00: 07: 09Z
  2. @ witty2017 il n'échouera pas. L'endroit où j'ai utilisé la fonction devait également vérifier si la propriété existe déjà ou non. si la propriété n'existe pas, elle retournera false. S'il trouve la propriété et la supprime, il retournera la valeur true.
    2017-07-17 05: 52: 42Z

Pour cloner un objet sans propriété:

Par exemple:

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

Et nous devons supprimer "a".

1.Avec une clé de propriété explicite:

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

2.Avec clé de la variable prop:

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

3.Fonction de flèche froide 😎:

 
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 }
    
11
2019-05-23 09: 02: 03Z

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é, par exemple key1, utilisez le mot-clé delete ainsi:

 
delete obj.key1

Vous pouvez également utiliser une notation de type tableau:

 
delete obj[key1]

Réf.: MDN .

    
7
2016-11-22 22: 11: 24Z

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 moi-même effectué le test sous Chrome 59. Il semble que la suppression soit environ 30 fois plus lente:

 
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 des autres opérations.

    
6
2017-07-26 07: 19: 30Z

Envisagez de créer un nouvel objet sans la propriété "regex" car l'objet d'origine peut toujours être référencé par d'autres parties de votre programme. Donc, vous devriez éviter de le manipuler.

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

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

console.log(newMyObject);
    
6
2017-10-23 10: 06: 31Z
  1. SyntaxError: Unexpected token '...'. Expected a property name.?
    2018-04-03 20: 24: 59Z
  2. Essayez-le avec un navigateur moderne tel que Firefox, Chromium ou Safari. Et j'espère que cela fonctionnera également avec Edge.
    2018-04-03 20: 45: 04Z
  3. Au lieu de cela, si vos clients vous obligent à prendre en charge des navigateurs obsolètes, vous pouvez envisager d'utiliser TypeScript, qui transcrit votre code dans une syntaxe héritée (+ vous donne l'avantage du type statique.) sécurité).
    2018-04-03 20: 48: 37Z

Object.assign () & Object.keys () & 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"];
        }
    }
);
    
6
2017-11-10 06: 36: 12Z
  1. 2017-09-19 08: 38: 03Z

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

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

console.log(myObject)
console.log(regex)
console.log(other)
    
6
2018-02-06 04: 28: 57Z

Essayez ceci

 
delete myObject['key'];
    
5
2017-05-26 06: 58: 29Z

Bonjour, vous pouvez essayer ce truc simple

 
var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);
    
5
2017-05-26 09: 28: 09Z

Utilisation de lodash

 
import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');

Utilisation de Ramda

 
R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
    
4
2017-09-14 14: 14: 07Z

Suppression de propriété en JavaScript

Il y a beaucoup d'options différentes présentées sur cette page, non pas parce que la plupart d'entre elles sont fausses - 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 votre équipe essaie de remplir. Pour répondre à votre question sans équivoque, il faut savoir:

  1. La version d'ECMAScript que vous ciblez
  2. La gamme de types d'objet sur lesquels vous souhaitez supprimer des propriétés et les types 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 sont tous des types de pointeurs de propriétés en JavaScript. depuis des années)
  3. 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 verboten sur votre équipe, ou utilisez-vous des techniques orientées objet mutatives de type far west?
  4. Souhaitez-vous y parvenir en JavaScript pur ou êtes-vous disposé à & capable d'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és" en JavaScript parmi lesquelles choisir afin de répondre à vos objectifs. Ils sont:

Suppression d'une 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 plus ancienne et la plus simple. catégorie de suppression de propriété la plus largement prise en charge. Il prend en charge Symbol & index de tableau 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 non propriétés configurables en mode strict .

Omission de propriété de chaîne basée sur le repos

Cette catégorie sert à opérer sur des instances d'objet brut ou de tableau dans les nouvelles versions d'ECVariations MAScript lorsqu'une approche non mutante est souhaitée et qu'il n'est pas nécessaire de prendre en compte les clés 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 :(

Suppression de la propriété d'un objet mutatif, en toute sécurité

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 brut ou de tableau 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 la bibliothèque

Cette catégorie permet généralement une plus grande flexibilité fonctionnelle, y compris la comptabilisation des symboles & omettre plusieurs propriétés dans une instruction:

 
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"
    
4
2017-12-14 02: 35: 29Z
source placée ici