如何从JavaScript对象中删除属性？

假设我创建一个对象，如下所示：

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

我应该如何删除属性

regex

以新的

myObject

结束，如下所示

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

---

要从对象中删除属性（改变对象），可以按如下方式执行：

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

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

演示

var myObject={
“ircEvent”：“PRIVMSG”，
“方法”：“newURI”，
“regex”：“^http://.*”
};
删除myObject.regex；
console.log（myObject）
var myObject={“ircEvent”：“privmg”，“method”：“newURI”，“regex”：“^http://.*”；
删除myObject.regex；
console.log（myObject.regex）；//日志：未定义
删除

操作符用于从对象中删除属性

const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false

请注意，对于数组，这与删除元素不同。要从数组中删除元素，请使用

array#splice

或

array#pop

。例如：

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

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

细节 JavaScript中的

delete

与C和C++中的关键字的功能不同：它不直接释放内存。相反，它的唯一目的是从对象中删除属性

const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false

对于数组，删除与索引对应的属性会创建稀疏数组（即，其中有一个“孔”的数组）。大多数浏览器将这些缺少的数组索引表示为“空”

请注意，

delete

不会将

array[3]

重新定位到

array[2]

中

JavaScript中不同的内置函数处理稀疏数组的方式不同

• for…in

  将完全跳过空索引

• 传统的

  for

  循环将为索引处的值返回

  undefined

• 任何使用

  Symbol.iterator

  的方法都将为索引处的值返回

  undefined

• forEach

  ，

  map

  和

  reduce

  将跳过缺少的索引

因此，

delete

操作符不应用于从数组中删除元素的常见用例。阵列有专门的方法来删除元素和重新分配内存：

Array#splice（）

和

Array#pop

数组#拼接（开始[，删除计数[，项1[，项2[，…]））

Array#splice

对数组进行变异，并返回所有删除的索引<代码>删除计数元素从索引

开始

和

项目1、项目2中删除。。。从索引
开始
将项n插入数组中。如果省略了
deleteCount
，则startIndex中的元素将被删除到数组的末尾

let a = [0,1,2,3,4]
a.splice(2,2) // returns the removed elements [2,3]
// ...and `a` is now [0,1,4]

在
Array.prototype
：
Array#slice
上还有一个名称类似但不同的函数

数组#切片（[begin[，end]]）
Array#slice
是非破坏性的，它返回一个新数组，其中包含从
start
到
end
的指示索引。如果未指定
end
，则默认为数组的末尾。如果
end
为正，则它指定要停止的基于零的非包容性索引。如果
end
为负数，则它通过从数组末尾倒数来指定要停止的索引（例如，-1将忽略最终索引）。如果
end您在问题标题
中使用的术语从JavaScript对象中删除属性
，可以用一些不同的方式进行解释。一个是删除整个内存和对象键列表，另一个只是将其从对象中删除。正如在其他一些答案中提到的那样，
delete
关键字是主要部分。假设您的对象是：

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

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

如果您这样做：

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

结果将是：

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

["ircEvent", "method"]

可以从对象关键帧中删除该特定关键帧，如：

delete myJSONObject["regex"];

然后您的对象使用
Object键。键（myJSONObject）
将是：

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

["ircEvent", "method"]

但关键是，如果您关心内存，并且希望从内存中删除整个对象，建议在删除密钥之前将其设置为null：

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

这里的另一个要点是要小心对同一对象的其他引用。例如，如果创建一个变量，如：

var regex = myJSONObject["regex"];

或者将其添加为指向另一个对象的新指针，如：

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

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

然后，即使您将其从对象
myJSONObject
中删除，该特定对象也不会从内存中删除，因为
regex
变量和
myOtherObject[“regex”]
仍有其值。那么，我们如何才能确定地从内存中删除该对象呢

答案是删除代码中的所有引用，指向该对象，并且不要使用
var
语句创建对该对象的新引用。关于
var
语句的最后一点，是我们通常面临的最关键的问题之一，因为使用
var
语句将防止删除创建的对象

这意味着在这种情况下，您将无法删除该对象，因为您已经通过
var
语句创建了
regex
变量，如果您这样做：

delete regex; //False

结果将是
false
，这意味着您的delete语句没有按预期执行。但是，如果您以前没有创建过该变量，并且只有
myOtherObject[“regex”]
作为您的最后一个现有引用，您可以通过如下方式删除它：

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

换句话说，只要代码中没有指向该对象的引用，JavaScript对象就会被杀死。


更新：
感谢@AgentME：

在删除属性之前将其设置为null并不能完成此操作
任何东西（除非物体已被物体密封。密封和
删除失败。除非您特别指定，否则通常不会出现这种情况
试试看）

获取有关
对象的更多信息。seal
：
J中的对象
let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

"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

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

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

delete Hogwarts.staff;

delete Hogwarts['staff'];

Hogwarts.staff.splice(3, 1);

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

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 { a, ...rest } = { a: 1, b: 2, c: 3 };

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

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

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

import omit from 'lodash/omit';

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

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

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

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

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

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

function deleteUser(key) {

 const newUsers = {}; 
 for (const uid in users) {
       if (uid !== key) {
       newUsers[uid] = users[uid];
 }
 return newUsers
}

delete users[key]