[英]How do I remove a property from a JavaScript object?
给定一个 object：
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 myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; delete myObject.regex; console.log(myObject);
对于任何有兴趣阅读更多相关信息的人，Stack Overflow 用户kangax在他们的博客上写了一篇关于delete语句的非常深入的博文， Understanding delete 。 强烈推荐。
如果你想要一个新对象，除了一些之外，所有的键都是原始的，你可以使用destructuring 。
演示
let myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; const {regex, ...newObj} = myObject; console.log(newObj); // has no 'regex' key console.log(myObject); // remains unchanged
JavaScript 中的对象可以被认为是键和值之间的映射。 delete运算符用于删除这些键，通常称为对象属性，一次删除一个。
var obj = { myProperty: 1 } console.log(obj.hasOwnProperty('myProperty')) // true delete obj.myProperty console.log(obj.hasOwnProperty('myProperty')) // false
delete操作符不直接释放内存，它不同于简单地将null或undefined的值分配给属性，因为属性本身从对象中删除。 请注意，如果被删除的属性的值是一个引用类型（一个对象），并且程序的另一部分仍然持有对该对象的引用，那么该对象当然不会被垃圾收集，直到对它的所有引用都有消失了。
delete仅适用于描述符将其标记为可配置的属性。
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"}; delete myObject.regex; console.log ( myObject.regex); // logs: undefined
这适用于 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与 C 和 C++ 中的关键字的功能不同：它不直接释放内存。 相反，它的唯一目的是从对象中删除属性。
对于数组，删除与索引对应的属性，会创建一个稀疏数组（即其中有一个“洞”的数组）。 大多数浏览器将这些缺失的数组索引表示为“空”。
var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]
请注意， delete不会将array[3]定位到array[2] 。
JavaScript 中不同的内置函数处理稀疏数组的方式不同。
for...in将完全跳过空索引。
传统的for循环将为索引处的值返回undefined 。
任何使用Symbol.iterator方法都会为索引处的值返回undefined 。
forEach ， map和reduce将简单地跳过丢失的索引。
因此， delete运算符不应用于从数组中删除元素的常见用例。 数组有专门的方法来删除元素和重新分配内存： Array#splice()和Array#pop 。
Array#splice改变数组，并返回任何删除的索引。 从索引start中删除deleteCount元素，并将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 。
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]
Array#pop从数组中删除最后一个元素，并返回该元素。 此操作更改数组的长度。
老问题，现代答案。 使用对象解构（ 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);
编辑：
要重新分配给同一个变量，请使用let ：
let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);
要完成Koen 的回答，如果您想使用传播语法删除动态变量，您可以这样做：
const key = 'a'; const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 }; console.log(foo); // 1 console.log(rest); // { b: 2, c: 3 }
* foo将是一个值为a （即 1）的新变量。
有几种常见的方法可以从对象中删除属性。
每个都有自己的优点和缺点（检查这个性能比较）：
它可读且简短，但是，如果您正在对大量对象进行操作，它可能不是最佳选择，因为它的性能未优化。
delete obj[key];
它比delete快两倍多，但是该属性不会被删除并且可以迭代。
obj[key] = null;
obj[key] = false;
obj[key] = undefined;
这个ES6运算符允许我们返回一个全新的对象，不包括任何属性，而不改变现有对象。 缺点是它的性能比上述更差，当您需要一次删除许多属性时，不建议使用它。
{ [key]: val, ...rest } = obj;
另一种选择是使用Underscore.js库。
请注意_.pick()和_.omit()都返回对象的副本并且不直接修改原始对象。 将结果分配给原始对象应该可以解决问题（未显示）。
参考：链接_.pick(object, *keys)
返回对象的副本，过滤后仅包含白名单键（或有效键数组）的值。
var myJSONObject =
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};
参考：链接_.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; object = rest;使用可变道具键：
const propKey = 'a'; const { [propKey]: propValue, ...rest } = object; object = rest;一个很酷的箭头函数😎：
const removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest; object = removeProperty('a', object);对于多个属性
const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})用法
object = removeProperties(object, 'a', 'b') // result => { c: 3 }
要么
const propsToRemove = ['a', 'b']
object = removeProperties(object, ...propsToRemove) // result => { c: 3 }
您在问题标题中使用的术语Remove a property from a JavaScript object可以用一些不同的方式解释。 一种是在整个内存和对象键列表中删除它，另一种是将它从您的对象中删除。 正如在其他一些答案中提到的那样， 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 ，这意味着您的 delete 语句未按预期执行。 但是，如果您之前没有创建该变量，并且您只有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;整个学生数组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也会弄乱你的索引。
因此，从对象中删除值时，请始终首先考虑您是在处理对象属性还是在处理数组值，然后根据此选择适当的策略。
如果你想尝试这个，你可以使用这个 Fiddle作为起点。
我个人使用Underscore.js或Lodash的对象和数组操作：
myObject = _.omit(myObject, 'regex');
使用delete方法是最好的方法，根据 MDN 描述，delete 操作符从对象中删除一个属性。 所以你可以简单地写：
delete myObject.regex;
// OR
delete myObject['regex'];
delete 运算符从对象中删除给定的属性。 删除成功返回true，否则返回false。 但是，重要的是要考虑以下情况：
如果您尝试删除的属性不存在，则删除不会有任何效果并返回 true
如果对象的原型链上存在同名的属性，那么删除后，对象将使用原型链中的属性（换句话说，删除只对自己的属性有影响）。
任何用 var 声明的属性都不能从全局作用域或函数作用域中删除。
因此，delete 不能删除全局范围内的任何函数（无论这是函数定义的一部分还是函数（表达式）的一部分）。
作为对象一部分的函数（除了
全局范围）可以用 delete 删除。任何用 let 或 const 声明的属性都不能从定义它们的范围中删除。 无法删除不可配置的属性。 这包括内置对象的属性，如 Math、Array、Object 和使用 Object.defineProperty() 等方法创建为不可配置的属性。
下面的代码片段给出了另一个简单的例子：
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
有关更多信息和查看更多示例，请访问以下链接：
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete
使用ES6：
（解构+传播运算符）
const myObject = {
regex: "^http://.*",
b: 2,
c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }
删除运算符是最好的方法。
一个实时示例显示：
var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
另一个解决方案，使用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);
但是，它会改变原始对象。 如果你想在没有指定键的情况下创建一个新对象，只需将 reduce 函数分配给一个新变量，例如：
(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);
这里有很多很好的答案，但我只想补充一点，当使用 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 中保留所有其他变量的索引。 看下面的例子，看看从 hash_map 中删除一个值后，“test2”的索引是如何没有改变的。
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"}
使用ramda#dissoc您将获得一个没有属性regex的新对象：
const newObject = R.dissoc('regex', myObject);
// newObject !== myObject
您还可以使用其他功能来实现相同的效果 - 省略、选择、...
试试下面的方法。 将Object属性值分配给undefined 。 然后将对象stringify并parse .
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"]; } } );
这是一种轻松删除条目的 ES6 方法：
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" }
Dan 断言“删除”非常慢，他发布的基准受到质疑。 所以我自己在 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 中基本上就有四类“属性删除”可供选择，以满足您的目标。 他们是：
当您想要保留/继续使用原始引用并且不在代码中使用无状态功能原则时，此类别用于对对象文字或对象实例进行操作。 此类别中的示例语法：
'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 版本。 但是，它是可变的，它违反了一些编程原则并具有性能影响。 在严格模式下用于不可配置的属性时，它也可能导致未捕获的异常。
当需要非可变方法并且您不需要考虑符号键时，此类别用于在较新的 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"
@johnstock ，我们还可以使用 JavaScript 的原型概念向对象添加方法，以删除调用对象中可用的任何传递键。
以上答案表示赞赏。
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 }
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}
您可以简单地使用delete关键字delete对象的任何属性。
例如：
var obj = {key1:"val1",key2:"val2",key3:"val3"}
要删除任何属性，例如key1 ，请使用delete关键字，如下所示：
delete obj.key1
或者，您也可以使用类似数组的符号：
delete obj[key1]
参考： MDN 。
您可以使用如下过滤器
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)
我已经使用Lodash "unset"使其也适用于嵌套对象......只需要编写小逻辑来获取omit方法预期的属性键的路径。
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>
var unset = require('lodash.unset'); unset(a, getPathOfKey(a, "price_index.final_price"));
考虑创建没有"regex"属性的新对象，因为原始对象始终可以被程序的其他部分引用。 因此，您应该避免对其进行操作。
const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; const { regex, ...newMyObject } = myObject; console.log(newMyObject);
const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*" }; const { regex, ...other } = myObject; console.log(myObject) console.log(regex) console.log(other)
您可以将ES6解构与rest运算符一起使用。
可以通过与rest运算符结合使用分解来删除属性。 在您的示例中，正则表达式被解构（忽略），其余属性作为其余部分返回。
const noRegex = ({ regex, ...rest }) => rest;
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
console.log(noRegex(myObjext)) //=> { "ircEvent": "PRIVMSG","method": "newURI" }
或者您可以动态排除此类属性，
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest
const removeRegex = removeProperty('regex') //=> { "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> { "ircEvent": "PRIVMSG", "regex":"^http://.*" }
尝试这个
delete myObject['key'];
您好，您可以尝试这种简单的排序
var obj = [];
obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};
delete(obj.key1);
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)
您也可以使用Object.entries将对象视为a2d数组，并像在普通数组中一样使用 splice 删除元素，或者像数组一样简单地过滤对象，然后将重建的对象分配回原始变量
如果不想修改原始对象。
删除属性而不改变对象
如果可变性是一个问题，您可以通过复制旧的所有属性来创建一个全新的对象，除了要删除的属性。
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);
删除对象的两种方法
使用for ... in
function deleteUser(key) { const newUsers = {}; for (const uid in users) { if (uid !== key) { newUsers[uid] = users[uid]; } return newUsers }要么
delete users[key]
说我创建一个对象，如下所示：
let myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
我应该如何删除属性regex以新的myObject结尾，如下所示？
let myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI"
};
让我们保持简单，重点：
只需将该特定属性/字段设置为 = undefined
var myObject = {
'i': "How are you?",
'am': "Dear",
'fine': "Hello"
};
myObject.am = undefined;
console.log(myObject);
> {i: "How are you?", am: undefined, fine: "Hello"}
有几个选项：
const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", }; delete myObject.regex; console.log(myObject);
const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", }; delete myObject['regex']; console.log(myObject); // or const name = 'ircEvent'; delete myObject[name]; console.log(myObject);
const myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", }; const { regex, ...myObjectRest} = myObject; console.log(myObjectRest);我们可以删除使用
let myObject = { "ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*", "regex1": "^http://.*", "regex2": "^http://.*", "regex3": "^http://.*", "regex4": "^http://.*" }; delete myObject.regex; // using delete object.property // Or delete myObject['regex1']; // using delete object['property'] const { regex2, regex3, regex4, ...newMyObject } = myObject; console.log(newMyObject);
您可以使用 Delete property[key] 从对象中删除属性
在 JavaScript 中，有两种常用方法可以从对象中删除属性。
第一种可变方法是使用delete object.property运算符。
第二种方法是不可变的，因为它不会修改原始对象，它是调用对象解构和扩展语法： const {property, ...rest} = object
简短的回答
var obj = {
data: 1,
anotherData: 'sample'
}
delete obj.data //this removes data from the obj
你只剩下
var obj = {
anotherData: 'sample'
}
const object = { prop1: 10, prop2: 20, prop3: 30, "test prop": "This is test props" } console.log(object); // will print all 4 props delete object.prop1; delete object["test prop"]; console.log(object); // will print only prop2 and prop3
如何设置条件以从 Javascript object 中删除属性？
[英]How do I set a condition to remove a property from Javascript object?
如何从 javascript 中的 object 中选择随机嵌套属性？
[英]How do i choose a random nested property from an object in javascript?
如何删除 JavaScript 中 object 的所有循环引用？
[英]How do I remove all circular references from an object in JavaScript?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.