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


14 Answers

Opérateur delete est étonnamment lent!

Regardez le benchmark .

Delete est le seul vrai moyen de supprimer les propriétés de l'objet sans les restes, mais il fonctionne ~ 100 fois plus lentement , par rapport à son "alternative", paramètre object[key] = undefined .

Cette alternative n'est pas la bonne réponse à cette question! Mais, si vous l'utilisez avec précaution, vous pouvez accélérer considérablement certains algorithmes. Si vous utilisez delete dans les boucles et que vous avez des problèmes de performances, lisez l'explication détaillée.

Quand devrait-on utiliser delete et quand set value to 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 passez l'objet résultat au code sur lequel vous n'avez pas de contrôle (ou lorsque vous n'êtes pas sûr de votre équipe ou de vous-même).

Il supprime la clé de la hashmap .

 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 clé reste à sa place dans la hashmap , seule la valeur est remplacée par undefined . Comprenez, que for..in boucle va encore itérer sur cette touche.

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

En utilisant cette méthode, tous les moyens de déterminer l'existence d'une propriété ne fonctionneront pas comme prévu.

Cependant, ce code:

object.field === undefined

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

Tests

Pour résumer, les différences concernent toutes les façons de déterminer l'existence de la propriété, et à propos de for..in loop.

 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!

Alors que l'utilisation de obj[prop] = undefined est plus rapide que celle de delete obj[prop] , une autre considération importante est que obj[prop] = undefined n'est pas toujours 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 le 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 entraîner une réconciliation mémoire coûteuse (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, il suffit de faire nodeRecords[i][lastTime] = undefined; causera une fuite de mémoire massive, car chaque image d'animation. À chaque trame, les 65536 éléments DOM occuperont 65536 emplacements supplémentaires, mais les 65536 emplacements précédents ne seront définis que de manière indéfinie, ce qui les laissera 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 l'opérateur de delete 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 vu dans l'extrait de code ci-dessus, il existe quelques rares cas d'utilisation appropriés pour l'opérateur de delete . Cependant, ne vous inquiétez pas trop de ce problème. Cela ne deviendra un problème qu'avec les objets à longue durée de vie qui reçoivent de nouvelles clés constamment ajoutées. Dans tous les autres cas (ce qui est presque tous les cas dans la programmation du monde réel), il est plus approprié d'utiliser obj[prop] = undefined . Le but principal de cette section est simplement de porter ceci à votre attention afin que dans la rare possibilité que cela devienne un problème dans votre code, alors vous pouvez plus facilement comprendre le problème et ainsi ne pas perdre des heures à disséquer votre code pour localiser et comprendre ce problème.

Ne pas toujours défini sur undefined

Un aspect de Javascript important est le polymorphisme. Le polymorphisme consiste à assigner les mêmes types de variable / slot-in-a-object différents comme on le voit 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 principaux problèmes non résolus avec les tableaux polymorphiques:

  1. Ils sont lents et inefficaces de mémoire. Lors de l'accès à un index spécifique, au lieu de simplement obtenir le type global pour le tableau, le navigateur doit à la place obtenir le type sur une base par 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 sera toujours stocké par le navigateur sous la forme d'un tableau polymorphe.

On peut assimiler le polymorphisme à une dépendance à la drogue. Au premier coup d'œil, il semble incroyablement lucratif: joli code duveteux. Ensuite, le codeur introduit leur tableau à la drogue du polymorphisme. Instantanément, le réseau polymorphe devient moins efficace, et il ne peut jamais devenir aussi efficace qu'il l'était auparavant puisqu'il est drogué. Pour corréler une telle situation à la vie réelle, quelqu'un sur la cocaïne pourrait même ne pas être capable d'utiliser une poignée de porte simple, encore moins être capable de calculer les chiffres de PI. De même, un tableau sur le médicament du polymorphisme ne peut jamais être aussi efficace qu'un tableau monomorphe.

Mais, comment une analogie de voyage de drogue se rapportent-elles à l'opération de delete ? La réponse hérite de la dernière ligne de code dans l'extrait ci-dessus. Ainsi, qu'il soit réexaminé, 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 fait. Par conséquent, il faut toujours, dans la mesure du possible, utiliser le type correspondant pour leurs objets afin de ne pas provoquer accidentellement de polymorphisme. Une telle personne peut utiliser la liste suivante comme référence générale pour les faire fonctionner. Cependant, veuillez ne pas utiliser explicitement les idées ci-dessous. Au lieu de cela, utilisez tout ce qui fonctionne bien pour votre code.

  • Lorsque vous utilisez un tableau / une variable typé à la primitive booléenne, utilisez false ou undefined comme valeur vide. Tout en évitant le polymorphisme inutile est bon, 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é à 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 lents (tout ce qui n'est pas compris avec NaN et Infinity ). Lorsqu'un entier est rétrogradé en double, il ne peut pas être promu en entier.
  • Lorsque vous utilisez un tableau / une variable typé à la primitive de chaîne, utilisez "" comme valeur vide.
  • Lorsque vous utilisez un symbole, attendez, pourquoi utilisez-vous un symbole?!?! Les symboles sont mauvais juju pour la performance. Tout ce qui est programmé pour utiliser les symboles peut être reprogrammé pour ne pas utiliser de symboles, ce qui donne un code plus rapide sans symboles. Les symboles sont vraiment juste du méta-sucre super inefficace.
  • Lorsque vous utilisez autre chose, utilisez null .

Cependant, soyez conscient! Ne commencez pas tout à coup à le faire avec tout votre code préexistant, car il risquerait de casser un tel code préexistant et / ou d'introduire des bogues étranges. Au contraire, une telle pratique efficace doit être mise en œuvre dès le début, et lors de la conversion du code préexistant, il est recommandé de double, triple, quadruple vérifier toutes les lignes relatives à cette tentative de mise à niveau de l'ancien code. risqué car c'est gratifiant.

Question

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 se terminer avec new myObject comme suit?

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};



Another solution, using 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);

However, it will mutate the original object. If you want to create a new object without the specified key, just assign the reduce function to a new variable, eg:

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




I have used lodash "unset" to make it happen for nested object also.. only this need to write small logic to get path of property key which expected by omit method.

  1. Method which returns property path as array

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>

  1. Then just using lodash unset method remove property from object.

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




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 de staff , la meilleure façon de le faire serait de faire ceci:

delete Hogwarts.staff;

Alternativement, vous pouvez aussi faire ceci:

delete Hogwarts['staff'];

De même, supprimer le tableau entier des étudiants serait fait en appelant delete Hogwarts.students; ou delete Hogwarts['students']; .

Suppression d'un index de tableau

Maintenant, si vous voulez supprimer un seul membre du personnel ou é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 d'index:

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

Remarque

Tandis que vous pouvez techniquement employer la delete pour un tableau, l'employer obtiendrait obtenir des résultats incorrects en appelant par exemple Hogwarts.staff.length plus tard. En d'autres termes, delete supprimerait l'élément, mais ne mettrait pas à jour la valeur de la propriété length . Utiliser delete aussi votre indexation.

Ainsi, lorsque vous supprimez des valeurs d'un objet, commencez toujours par déterminer si vous traitez des propriétés d'objet ou si vous traitez des valeurs de tableau, et choisissez la stratégie appropriée basée sur cela.

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




Comme d'autres l'ont dit, vous pouvez utiliser delete . Mais JavaScript est un langage OOP, donc tout est un objet. Ainsi, je pense qu'il est nécessaire de souligner une mise en garde particulière.

Dans les tableaux, contrairement aux anciens objets simples, l'utilisation de delete laisse derrière les ordures sous la forme null , créant un "trou" dans le tableau.

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

Comme vous pouvez le voir, la delete ne fonctionne pas toujours comme on pourrait s'y attendre. La valeur est remplacée, mais la mémoire n'est pas réaffectée.

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

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 ). Disons aussi que le code utilise les indices numériques des membres du tableau pour les "titrer" quand ils dessinent à l'écran. Pourquoi faites-vous cela plutôt que de simplement stocker le "titre" aussi bien? Parce que ... des raisons .

Bon, disons simplement que vous essayez d'économiser de la mémoire à la demande de cet utilisateur qui exécute un mini-ordinateur PDP-11 à partir des années 1960 sous UNIX, et qui a écrit sa propre imprimante basée sur Elinks, compatible JavaScript, compatible avec les imprimantes navigateur parce que X11 est hors de question .

De plus en plus stupide, la delete de ce tableau aura pour effet de polluer le tableau et causera probablement des bugs dans l'application plus tard. Et si vous vérifiez null , il sautera directement les nombres résultant dans les onglets 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 définitivement pas ce que tu voulais.

Maintenant, vous pouvez garder un second itérateur, comme j , pour incrémenter uniquement lorsque des valeurs valides sont lues dans le tableau. Mais cela ne résoudrait pas exactement le problème de null , et vous devez toujours s'il vous plaît cet utilisateur troll PDP-11. Hélas, son ordinateur n'a tout simplement pas assez de mémoire pour contenir ce dernier entier (ne demandez pas comment il gère un tableau de largeur variable ...) .

Alors, il t'envoie un mail 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 maintenant, vous êtes à la fin de votre esprit. Ce gars s'est plaint sans arrêt de votre application, et vous voulez lui dire de se taire et d'aller chercher un meilleur ordinateur.

Heureusement, les tableaux ont une méthode spécialisée pour supprimer des index et Array.prototype.splice() 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 plu à M. PDP-11. Hourra! (Je le lui dirais quand même ...)




Essaye ça

delete myObject['key'];



Dan's assertion that 'delete' is very slow and the benchmark he posted were doubted. So I carried out the test myself in Chrome 59. It does seem that 'delete' is about 30 times slower:

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

Note that I purposedly carried out more than one 'delete' operations in one loop cycle to minimize the effect caused by the other operations.







Une autre alternative consiste à utiliser la bibliothèque Underscore.js .

Notez que _.pick() et _.omit() retournent une copie de l'objet et ne modifient pas directement l'objet d'origine. Assigner le résultat à l'objet original devrait faire l'affaire (non montré).

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

Renvoie une copie de l'objet, filtrée pour avoir uniquement des valeurs pour les clés de 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: link _.omit (objet, * touches)

Renvoie une copie de l'objet, filtrée pour omettre les clés de 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 la même manière.




Using delete method is the best way to do that, as per MDN description, the delete operator removes a property from an object. so you can simply write:

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

The delete operator removes a given property from an object. On successful deletion, it will return true, else false will be returned. However, it is important to consider the following scenarios:

  • If the property which you are trying to delete does not exist, delete will not have any effect and will return true

  • If a property with the same name exists on the object's prototype chain, then, after deletion, the object will use the property from the prototype chain (in other words, delete only has an effect on own properties).

  • Any property declared with var cannot be deleted from the global scope or from a function's scope.

  • As such, delete cannot delete any functions in the global scope (whether this is part from a function definition or a function (expression).

  • Functions which are part of an object (apart from the
    global scope) can be deleted with delete.

  • Any property declared with let or const cannot be deleted from the scope within which they were defined. Non-configurable properties cannot be removed. This includes properties of built-in objects like Math, Array, Object and properties that are created as non-configurable with methods like Object.defineProperty().

The following snippet gives another simple example:

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

For more info about and seeing more example, visit the link below:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…




Ce post est très ancien et je le trouve très utile, j'ai donc décidé de partager la fonction inachevée que j'ai écrite au cas où quelqu'un d'autre verrait ce post et je pense que ce n'est pas si simple que ça en PHP.

La raison de l'écriture de cette nouvelle fonction unset est de conserver l'index de toutes les autres variables de cette hash_map. Regardez l'exemple suivant, et voyez comment l'index de "test2" n'a pas changé après avoir enlevé une valeur du 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"}



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




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

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

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




Try the following method. Assign the Object property value to undefined . Then stringify the object and parse .

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

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

console.log(myObject);




you can use the delete operator as of below.

 var multiverse = {
        earth1: "Silver Age",
        earth2: "Golden Age"
    };

delete multiverse.earth2;//will return true if it finds 

// Outputs: { earth1: "Silver Age" }
console.log(multiverse);

The delete operator also has a return value. If it succeeds in deleting a property, it will return true. If it fails to delete a property because the property is unwritable it will return false , or if in strict mode it will throw an error.




Related