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

要从对象中删除属性（改变对象），您可以这样做：

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

演示

var myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" };删除 myObject.regex;控制台.log(myObject);

对于有兴趣了解更多相关信息的任何人，Stack Overflow 用户 kangax 在他们的博客 Understanding delete 上写了一篇关于 delete 声明的非常深入的博文。强烈推荐。

如果您想要一个 new 对象，其中包含除一些之外的所有原始键，您可以使用 destructuring。

演示

让 myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; const {regex, ...newObj} = myObject;控制台.log(newObj); // 没有“正则表达式”键 console.log(myObject); // 保持不变

---

JavaScript 中的对象可以被认为是键和值之间的映射。 delete 运算符用于删除这些键，通常称为对象属性，一次一个。

var obj = { myProperty: 1 } console.log(obj.hasOwnProperty('myProperty')) // true 删除 obj.myProperty console.log(obj.hasOwnProperty('myProperty')) // false

delete 运算符不直接释放内存，它不同于简单地将 null 或 undefined 的值分配给属性，因为属性 本身 已从对象中删除。请注意，如果已删除属性的 value 是引用类型（对象），并且程序的另一部分仍然持有对该对象的引用，那么该对象当然不会是垃圾收集，直到所有对它的引用都消失了。

delete 仅适用于描述符将其标记为可配置的属性。

---

老问题，现代答案。使用对象解构这一 ECMAScript 6 功能，它非常简单：

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

或使用问题示例：

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

You can see it in action in the Babel try-out editor.

编辑：

要重新分配给同一个变量，请使用 let：

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

---

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};删除 myObject.regex;控制台.log (myObject.regex); // 日志：未定义

这适用于 Firefox 和 Internet Explorer，我认为它适用于所有其他人。

---

delete 运算符用于从对象中删除属性。

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]

细节

严格来说，JavaScript 中不可能真正删除任何内容。 delete 运算符既不删除对象也不释放内存。相反，它将其操作数设置为 undefined 并操纵父对象以使该成员消失。

let parent = {
    member: { str: "Hello" }
};
let secondref = parent.member;

delete parent.member;
parent.member;        // undefined
secondref;            // { str: "Hello" }

对象未被删除。只有参考是。仅当删除对对象的所有引用时，垃圾收集器才会释放内存。

另一个重要的警告是 delete 运算符不会为您重新组织结构，其结果可能看起来违反直觉。例如，删除数组索引会在其中留下一个“洞”。

let array = [0, 1, 2, 3]; // [0, 1, 2, 3]
delete array[2];          // [0, 1, empty, 3]

这是因为数组是对象。所以索引与键相同。

let fauxarray = {0: 1, 1: 2, length: 2};
fauxarray.__proto__ = [].__proto__;
fauxarray.push(3);
fauxarray;                // [1, 2, 3]
Array.isArray(fauxarray); // false
Array.isArray([1, 2, 3]); // true

JavaScript 中不同的内置函数以不同的方式处理带有孔的数组。

for..in 语句将完全跳过空索引。

一个简单的 for 循环将在索引处产生未定义的值。

任何使用 Symbol.iterator 的方法都将为索引处的值返回 undefined。

forEach、map 和 reduce 将简单地跳过丢失的索引，但不会删除它

例子：

let array = [1, 2, 3]; // [1,2,3]
delete array[1];       // [1, empty, 3]
array.map(x => 0);     // [0, empty, 0]

因此，delete 运算符不应用于从数组中删除元素的常见用例。数组有一个专门的方法来删除元素和重新分配内存：Array#splice() 和 Array#pop。

Array#splice(start[, deleteCount[, item1[, item2[, ...]]]])

Array#splice 改变数组，并返回所有移除的索引。 deleteCount 元素从索引 start 中删除，并且 item1, item2... itemN 从索引 start 插入到数组中。如果省略 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。

数组#slice([开始[，结束]])

Array#slice 是非破坏性的，并返回一个新数组，其中包含从 start 到 end 的指示索引。如果 end 未指定，则默认为数组的末尾。如果 end 为正数，则它指定要停止的从零开始的 非包含 索引。如果 end 为负数，它通过从数组末尾倒数指定要停止的索引（例如，-1 将省略最终索引）。如果 end <= start，则结果为空数组。

let a = [0,1,2,3,4]
let slices = [
    a.slice(0,2),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ]

//   a           [0,1,2,3,4]
//   slices[0]   [0 1]- - -   
//   slices[1]    - - - - -
//   slices[2]    - -[3]- -
//   slices[3]    - -[2 4 5]

数组#pop

Array#pop 从数组中删除最后一个元素，并返回该元素。此操作更改数组的长度。相反的操作是push

数组#shift

Array#shift 与 pop 类似，不同之处在于它删除了第一个元素。相反的操作是unshift。

---

扩展语法 (ES6)

要完成 Koen's answer，如果您想使用展开语法删除动态变量，您可以这样做：

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

* foo 将是一个值为 a（即 1）的新变量。

扩展答案😇

有几种常见的方法可以从对象中删除属性。
每一种都有自己的优缺点 (check this performance comparison)：

Delete Operator

它可读且简短，但是，如果您对大量对象进行操作，它可能不是最佳选择，因为它的性能未优化。

delete obj[key];

Reassignment

它比 delete 快两倍以上，但是该属性未被删除并且可以迭代。

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

Spread Operator

这个 ES6 运算符允许我们返回一个全新的对象，不包括任何属性，而不改变现有对象。缺点是它的性能比上述更差，当您需要一次删除许多属性时不建议使用它。

{ [key]: val, ...rest } = obj;

---

另一种选择是使用 Underscore.js 库。

请注意，_.pick() 和 _.omit() 都返回对象的副本，并且不直接修改原始对象。将结果分配给原始对象应该可以解决问题（未显示）。

参考：link _.pick(object, *keys)

返回对象的副本，过滤后仅包含白名单键（或有效键数组）的值。

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

_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

参考：link _.omit(object, *keys)

返回对象的副本，过滤以省略列入黑名单的键（或键数组）。

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

_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

对于数组，_.filter() 和 _.reject() 可以以类似的方式使用。

---

要克隆没有属性的对象：

例如：

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

我们需要删除 a。

使用明确的道具键： const { a, ...rest } = object;对象=休息；使用可变道具键： const propKey = 'a'; const { [propKey]: propValue, ...rest } = object;对象=休息；一个很酷的箭头函数😎： const removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest; object = removeProperty('a', object);对于多个属性 const removeProperties = (object, ...keys) => (keys.length ? removeProperties(removeProperty(keys.pop(), object), ...keys) : object);

用法

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

或者

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

---

您在问题标题中使用的术语，从 JavaScript 对象中删除属性，可以用一些不同的方式来解释。一种是从整个内存和对象键列表中删除它，另一种是从对象中删除它。正如其他一些答案中提到的那样，delete 关键字是主要部分。假设您的对象如下：

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

如果你这样做：

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

结果将是：

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

您可以从对象键中删除该特定键，例如：

delete myJSONObject["regex"];

那么您使用 Object.keys(myJSONObject) 的对象键将是：

["ircEvent", "method"]

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

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

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

var regex = myJSONObject["regex"];

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

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

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

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

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

delete regex; //False

结果将是 false，这意味着您的删除语句没有按预期执行。但是，如果您之前没有创建该变量，并且您只有 myOtherObject["regex"] 作为您的最后一个现有引用，您可以通过删除它来完成此操作，如下所示：

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

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

更新：

感谢@AgentME：

在删除之前将属性设置为 null 不会完成任何事情（除非对象已被 Object.seal 密封并且删除失败。除非您特别尝试，否则通常不会出现这种情况）。

要获得有关 Object.seal 的更多信息：Object.seal()

---

ECMAScript 2015（或 ES6）带有内置的 Reflect 对象。可以通过使用目标对象和属性键作为参数调用 Reflect.deleteProperty() 函数来删除对象属性：

Reflect.deleteProperty(myJSONObject, 'regex');

这相当于：

delete myJSONObject['regex'];

但是，如果对象的属性不可配置，则不能使用 deleteProperty 函数或 delete 运算符删除它：

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

Object.freeze() 使对象的所有属性都不可配置（除了其他东西）。 deleteProperty 函数（以及 delete operator）在尝试删除它的任何属性时返回 false。如果属性是可配置的，它返回 true，即使属性不存在。

delete 和 deleteProperty 之间的区别在于使用严格模式时：

"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

---

假设您有一个如下所示的对象：

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

删除对象属性

如果您想使用整个 staff 数组，正确的方法是这样做：

delete Hogwarts.staff;

或者，您也可以这样做：

delete Hogwarts['staff'];

同样，可以通过调用 delete Hogwarts.students; 或 delete Hogwarts['students']; 来删除整个学生数组。

删除数组索引

现在，如果您要删除单个员工或学生，则过程有点不同，因为这两个属性本身都是数组。

如果您知道您的员工的索引，您可以简单地执行以下操作：

Hogwarts.staff.splice(3, 1);

如果您不知道索引，您还必须进行索引搜索：

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

笔记

虽然从技术上讲，您可以将 delete 用于数组，但在稍后调用例如 Hogwarts.staff.length 时，使用它会导致得到不正确的结果。换句话说，delete 会删除元素，但不会更新 length 属性的值。使用 delete 也会弄乱您的索引。

因此，从对象中删除值时，请始终首先考虑您是在处理对象属性还是在处理数组值，并据此选择适当的策略。

如果您想对此进行试验，可以使用 this Fiddle 作为起点。

---

我个人使用 Underscore.js 或 Lodash 进行对象和数组操作：

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

---

使用 delete 方法是最好的方法，根据 MDN 的描述，delete 操作符从对象中删除一个属性。所以你可以简单地写：

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

删除运算符从对象中删除给定的属性。删除成功返回true，否则返回false。但是，重要的是要考虑以下情况：

如果您尝试删除的属性不存在，则 delete 不会产生任何效果并返回 true

如果对象的原型链上存在同名的属性，那么在删除后，对象将使用原型链中的属性（也就是说，删除只对自己的属性有影响）。

任何用 var 声明的属性都不能从全局作用域或函数作用域中删除。

因此，delete 不能删除全局范围内的任何函数（无论是函数定义的一部分还是函数（表达式）的一部分。作为对象一部分的函数（除了全局范围）可以用 delete 删除。

任何用 let 或 const 声明的属性都不能从定义它们的范围中删除。无法删除不可配置的属性。这包括内置对象的属性，如 Math、Array、Object 和使用 Object.defineProperty() 等方法创建为不可配置的属性。

下面的代码片段给出了另一个简单的例子：

var Employee = { age: 28, name: 'Alireza', designation: 'developer' } console.log(delete Employee.name); // 返回 true console.log(delete Employee.age); // 返回 true // 当试图删除不存在的属性时， // 返回 true console.log(delete Employee.salary); // 返回真

有关更多信息和查看更多示例，请访问以下链接：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

---

另一种解决方案，使用 Array#reduce。

var myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; myObject = Object.keys(myObject).reduce(function(obj, key) { if (key != "regex") { //你要删除的键 obj[key] = myObject[key]; } return obj; } , {});控制台.log(myObject);

但是，它将改变原始对象。如果你想创建一个没有指定键的新对象，只需将reduce函数分配给一个新变量，例如：

(ES6)

const myObject = { ircEvent: 'PRIVMSG', 方法: 'newURI', 正则表达式: '^http://.*', }; const myNewObject = Object.keys(myObject).reduce((obj, key) => { key !== 'regex' ? obj[key] = myObject[key] : null; return obj; }, {});控制台.log(myNewObject);

---

这里有很多好的答案，但我只想指出，当使用 delete 删除 JavaScript 中的属性时，首先检查该属性是否存在以防止错误通常是明智的。

例如

var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

由于 JavaScript 的动态特性，经常出现您根本不知道该属性是否存在的情况。在 && 之前检查 obj 是否存在还可以确保您不会因为在未定义的对象上调用 hasOwnProperty() 函数而引发错误。

抱歉，如果这没有添加到您的特定用例中，但我相信这是一个很好的设计，可以在管理对象及其属性时进行调整。

---

这篇文章很老了，我觉得它很有帮助，所以我决定分享我写的 unset 函数，以防其他人看到这篇文章并想为什么它不像 PHP 的 unset 函数那么简单。

编写这个新的 unset 函数的原因是在这个 hash_map 中保留所有其他变量的索引。看下面的例子，看看“test2”的索引在从 hash_map 中删除一个值后没有改变。

功能 unset(unsetKey, unsetArr, Resort) { var tempArr = unsetArr; var unsetArr = {};删除 tempArr[unsetKey];如果（度假村）{ j = -1; } for (i in tempArr) { if (typeof(tempArr[i]) !== 'undefined') { if (resort) { j++; } 其他 { j = i; } unsetArr[j] = tempArr[i]; } } 返回 unsetArr; } var unsetArr = ['test', 'deletedString', 'test2']; console.log(unset('1', unsetArr, true)); // 输出对象 {0: "test", 1: "test2"} console.log(unset('1', unsetArr, false)); // 输出对象 {0: "test", 2: "test2"}

---

试试下面的方法。将 Object 属性值分配给 undefined。然后 stringify 对象和 parse。

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"}; myObject.regex = 未定义； myObject = JSON.parse(JSON.stringify(myObject));控制台.log(myObject);

---

使用 ramda#dissoc 您将获得一个没有属性 regex 的新对象：

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

您还可以使用其他函数来实现相同的效果 - 省略、选择、...

---

有几种方法可以从对象中删除属性：

使用点属性访问器删除

const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", };删除 myObject.regex;控制台.log(myObject);

使用方括号属性访问器删除

const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", };删除 myObject['regex'];控制台.log(myObject); // 或 const name = 'ircEvent';删除我的对象[名称]；控制台.log(myObject);

替代选项，但以不可变的方式而不改变原始对象，是使用对象解构和休息语法。

const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", }; const { 正则表达式，...myObjectRest} = myObject;控制台.log(myObjectRest);

---

使用 Lodash

import omit from 'lodash/omit';

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

使用 Ramda

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

---

如果要删除深深嵌套在对象中的属性，则可以使用以下递归函数，并将属性的路径作为第二个参数：

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: {}}}

---

Object.assign() & Object.keys() & Array.map()

const obj = { "Filters":[ { "FilterType":"between", "Field":"BasicInformationRow.A0", "MaxValue":"2017-10-01", "MinValue":"2017-09-01 ", "Value":"过滤值" } ] };让 new_obj1 = Object.assign({}, obj.Filters[0]);让 new_obj2 = Object.assign({}, obj.Filters[0]); /* // 旧版本 let shape_obj1 = Object.keys(new_obj1).map( (key, index) => { switch (key) { case "MaxValue": delete new_obj1["MaxValue"]; break; case "MinValue" : 删除 new_obj1["MinValue"]; break; } return new_obj1; } )[0]; let shape_obj2 = Object.keys(new_obj2).map( (key, index) => { if(key === "Value"){ delete new_obj2["Value"]; } return new_obj2; } )[0]; */ // 新版本！ let shape_obj1 = Object.keys(new_obj1).forEach( (key, index) => { switch (key) { case "MaxValue": delete new_obj1["MaxValue"]; break; case "MinValue": delete new_obj1["MinValue "]; 休息; 默认: 休息; } } ); let shape_obj2 = Object.keys(new_obj2).forEach( (key, index) => { if(key === "Value"){ delete new_obj2["Value"]; } } );

---

这是一种轻松删除条目的 ES6 方法：

让 myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" };常量 removeItem = '正则表达式'; const { [removeItem]: remove, ...rest } = myObject;控制台.log（删除）； // "^http://.*" console.log(rest); // Object { ircEvent: "PRIVMSG", method: "newURI" }

---

Dan's assertion“删除”非常慢，他发布的基准受到质疑。所以我自己在 Chrome 59 中进行了测试。“删除”似乎慢了大约 30 倍：

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

请注意，我特意在一个循环周期中执行了多个“删除”操作，以尽量减少其他操作造成的影响。

---

JavaScript 中的属性删除

此页面上提供了许多不同的选项，不是因为大多数选项都是错误的——或者因为答案是重复的——而是因为适当的技术取决于你所处的情况以及你和/或你的任务目标团队正在努力实现。要明确回答您的问题，您需要知道：

您所针对的 ECMAScript 版本 您想要删除属性的对象类型范围以及您需要能够省略的属性名称的类型（仅限字符串？符号？从任意对象映射的弱引用？这些都是类型多年来 JavaScript 中的属性指针）您和您的团队使用的编程精神/模式。你喜欢函数式方法并且你的团队中禁止使用变异，还是使用狂野的西部变异面向对象技术？您是希望在纯 JavaScript 中实现这一点，还是愿意并能够使用 3rd-party 库？

一旦这四个查询得到回答，JavaScript 中基本上就有四种“属性删除”类别可供选择，以满足您的目标。他们是：

可变对象属性删除，不安全

当您想要保留/继续使用原始引用并且不在代码中使用无状态功能原则时，此类别用于对对象文字或对象实例进行操作。此类别中的示例语法：

'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

这个类别是最古老、最直接的 &最广泛支持的财产移除类别。它支持Symbol &除了字符串之外的数组索引，并且适用于除第一个版本之外的所有 JavaScript 版本。但是，它是可变的，它违反了一些编程原则并具有性能影响。在 non-configurable properties in strict mode 上使用时，它还可能导致未捕获的异常。

基于 Rest 的字符串属性省略

当需要非可变方法并且您不需要考虑符号键时，此类别用于在较新的 ECMAScript 风格中对普通对象或数组实例进行操作：

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

此外，虽然就地改变对象不是无状态的，但您可以使用 Reflect.deleteProperty 的函数特性来执行部分应用程序和其他函数技术，这些技术在 delete 语句中是不可能的。

基于语法的字符串属性省略

当需要非可变方法并且您不需要考虑符号键时，此类别用于在较新的 ECMAScript 风格中对普通对象或数组实例进行操作：

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://.*" }; // 方式 1 let filter1 = {} Object.keys({...myObject}).filter(d => { if(d !== 'regex'){ filter1[d] = myObject[d]; } } ) console.log(filter1) // 方式 2 let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d => d[0] !== 'regex' )) console.log （过滤器2）

---

@johnstock，我们还可以使用 JavaScript 的原型设计概念向对象添加方法，以删除调用对象中可用的任何传递键。

以上答案表示赞赏。

var myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; // 第一种直接方式删除 myObject.regex; // 删除 myObject["regex"] console.log(myObject); // { ircEvent: 'PRIVMSG', method: 'newURI' } // 2 way - 通过使用 JavaScript 的原型概念 Object.prototype.removeFromObjectByKey = function(key) { // 如果 key 存在，删除它并返回 true if (this[key] !== undefined) { delete this[key] return true; } // 否则返回 false return false; } var isRemoved = myObject.removeFromObjectByKey('method') console.log(myObject) // { ircEvent: 'PRIVMSG' } // 更多示例 var obj = { a: 45, b: 56, c: 67 } console.log (obj) // { a: 45, b: 56, c: 67 } // 从 obj 中移除键 'a' isRemoved = obj.removeFromObjectByKey('a') console.log(isRemoved); //true console.log(obj); // { b: 56, c: 67 } // 从不存在的 obj 中删除键 'd' var isRemoved = obj.removeFromObjectByKey('d') console.log(isRemoved); // false console.log(obj); // { b: 56, c: 67 }

---

我已经使用 Lodash "unset" 来实现嵌套对象...只是这需要编写小逻辑来获取 omit 方法所期望的属性键的路径。

将属性路径作为数组返回的方法

var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450", "lt":"500"}}}, {"bool" :{"应该":[{"term":{"color_value.keyword":"Black"}}]}}]}};函数 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);返回 t; } document.getElementById("output").innerHTML =JSON.stringify(getPathOfKey(a,"price_index.final_price"))

然后只需使用 Lodash unset 方法从对象中删除属性。

var unset = require('lodash.unset');未设置（a，getPathOfKey（a，“price_index.final_price”））；

---

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

您也可以使用 Object.entries 将对象视为 a2d 数组，并像在普通数组中一样使用 splice 删除元素，或者像数组一样简单地过滤对象，并分配重建的对象回到原来的变量

---

如果您不想修改原始对象。

在不改变对象的情况下删除属性

如果可变性是一个问题，您可以通过复制旧对象的所有属性来创建一个全新的对象，除了您要删除的属性。

让 myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" };让道具 = '正则表达式'; const updatedObject = Object.keys(myObject).reduce((object, key) => { if (key !== prop) { object[key] = myObject[key] } return object }, {}) console.log(更新对象）；

---