const key = 'a';
const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };
console.log(foo);  // 1
console.log(rest); // { b: 2, c: 3 }

Antwoord 7

Een ander alternatief is om de bibliotheek Underscore.jste gebruiken.

Merk op dat _.pick()en _.omit()beide een kopie van het object retourneren en het oorspronkelijke object niet rechtstreeks wijzigen. Het toewijzen van het resultaat aan het originele object zou voldoende moeten zijn (niet getoond).

Referentie: link_.pick(object, *keys)

Retourneer een kopie van het object, gefilterd om alleen waarden te hebben voor de
op de witte lijst geplaatste sleutels (of reeks geldige sleutels).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Referentie: link_.omit(object, *keys)

Retourneer een kopie van het object, gefilterd om de . weg te laten
sleutels op de zwarte lijst (of reeks sleutels).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Voor arrays kunnen _.filter()en _.reject()op een vergelijkbare manier worden gebruikt.

Antwoord 8

Een object klonen zonder eigenschap:

Bijvoorbeeld:

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

En we moeten averwijderen.

1. Met een expliciete prop-sleutel:

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

2. Met een variabele prop-sleutel:

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

3. Een coole pijlfunctie😎:

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

4. Voor meerdere woningen

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

Gebruik

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

Of

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

Antwoord 9

ECMAScript 2015 (of ES6) werd geleverd met ingebouwde Reflectvoorwerp. Het is mogelijk om de objecteigenschap te verwijderen door Reflect.deleteProperty()functie met doelobject en eigenschapssleutel als parameters:

Reflect.deleteProperty(myJSONObject, 'regex');

wat gelijk is aan:

delete myJSONObject['regex'];

Maar als de eigenschap van het object niet configureerbaar is, kan deze niet worden verwijderd met de functie deleteProperty of de operator delete:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze()maakt alle eigenschappen van object niet configureerbaar (naast andere dingen). Functie deleteProperty(evenals delete-operator) retourneert falsewanneer wordt geprobeerd een van zijn eigenschappen te verwijderen. Als eigenschap configureerbaar is, wordt truegeretourneerd, zelfs als eigenschap niet bestaat.

Het verschil tussen deleteen deletePropertyis bij gebruik van de strikte modus:

"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

Antwoord 10

Stel dat je een object hebt dat er als volgt uitziet:

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

Een objecteigenschap verwijderen

Als u de hele staffarray wilt gebruiken, is de juiste manier om dit te doen, dit te doen:

delete Hogwarts.staff;

U kunt ook dit doen:

delete Hogwarts['staff'];

Op dezelfde manier zou het verwijderen van de hele studentenarray gedaan worden door delete Hogwarts.students;of delete Hogwarts['students'];aan te roepen.

Een array-index verwijderen

Als je nu een enkele medewerker of student wilt verwijderen, is de procedure een beetje anders, omdat beide eigenschappen zelf arrays zijn.

Als u de index van uw personeelslid kent, kunt u dit eenvoudig doen:

Hogwarts.staff.splice(3, 1);

Als u de index niet kent, moet u ook een indexzoekopdracht uitvoeren:

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

Opmerking

Hoewel je technisch gezien deletevoor een array kunt gebruiken, zou het gebruik ervan leiden tot onjuiste resultaten wanneer je later bijvoorbeeld Hogwarts.staff.lengthaanroept. Met andere woorden, deletezou het element verwijderen, maar de waarde van de eigenschap lengthniet bijwerken. Het gebruik van deletezou ook uw indexering in de war brengen.

Dus, wanneer u waarden uit een object verwijdert, moet u altijd eerst overwegen of u te maken heeft met objecteigenschappen of dat u te maken heeft met arraywaarden, en op basis daarvan de juiste strategie kiest.

Als u hiermee wilt experimenteren, kunt u deze viool als uitgangspunt gebruiken .

11

I Persoonlijk gebruik underscore.js of Lodash voor object en array manipulatie:

myObject = _.omit(myObject, 'regex');

12

Gebruik Delete Methode is de beste manier om dat te doen, volgens de MDN-beschrijving, de Delete Operator verwijdert een eigenschap van een object. Dus je kunt gewoon schrijven:

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

De Delete Operator verwijdert een gegeven eigenschap vanuit een object. Op
Succesvolle deletie, het zal true retourneren, anders is onwaar geretourneerd.
Het is echter belangrijk om de volgende scenario’s te overwegen:

• Als de eigenschap die u probeert te verwijderen niet bestaat, verwijdert u niet
  Zal geen effect hebben en zal het true retourneren

• Als een eigenschap met dezelfde naam bestaat op het prototype van het object
  ketting, dan, na het verwijderen, zal het object het eigendom van de
  Prototypeketting (met andere woorden, verwijder alleen een effect op eigen
  eigenschappen).

• Elke eigenschap die is gedeclareerd, kan niet worden verwijderd uit de wereldwijde reikwijdte
  of van de reikwijdte van een functie.

• Als zodanig kan verwijderen geen functies in de wereldwijde reikwijdte verwijderen (of dit deel uitmaakt van een functiedefinitie of een functie (expressie).

• Functies die deel uitmaken van een object (afgezien van de
  Global Scope) kan worden verwijderd met Verwijderen.

• Eigenschappen gedeclareerd met let of const kunnen niet worden verwijderd uit het bereik waarbinnen ze zijn gedefinieerd. Niet-configureerbare eigenschappen kunnen niet worden verwijderd. Dit omvat eigenschappen van ingebouwde objecten zoals Math, Array, Object en eigenschappen die zijn gemaakt als niet-configureerbaar met methoden zoals Object.defineProperty().

Het volgende fragment geeft nog een eenvoudig voorbeeld:

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

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

var obj = {"property":"value", "property2":"value"};
if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

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

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));
console.log(myObject);

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

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};
deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);
//Prints {level1: {level2: {}}}

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

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
const removeItem = 'regex';
const { [removeItem]: remove, ...rest } = myObject;
console.log(remove); // "^http://.*"
console.log(rest); // Object { ircEvent: "PRIVMSG", method: "newURI" }

'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

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

'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

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

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"

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 }

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

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
// Way 1
let filter1 = {}
  Object.keys({...myObject}).filter(d => {
  if(d !== 'regex'){
    filter1[d] = myObject[d];
  }
})
console.log(filter1)
// Way 2
let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d =>
d[0] !== 'regex'
))
console.log(filter2)

let myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
obj = Object.fromEntries(
    Object.entries(myObject).filter(function (m){
        return m[0] != "regex"/*or whatever key to delete*/
    }
))
console.log(obj)

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) => {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})
console.log(updatedObject);

delete users[key]