java 把一个类的某些属性删除 java怎么删除对象属性

转载

mob64ca140b0bc8 2024-08-25 23:23:25

文章标签 java 把一个类的某些属性删除 javascript javascript-objects object-properties 数组 文章分类 Java 后端开发

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

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

删除属性regex以产生新的myObject的最佳方法是什么？

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

#1楼

2018年7月21日更新：很长时间以来，我对这个答案感到很尴尬，所以我认为现在是我应该稍微加以解决的时候了。只需一点注释，澄清和格式化，即可帮助您快速阅读此答案中不必要的冗长和复杂的部分。

简短版本

问题的实际答案

正如其他人所说，可以使用delete 。

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

等效数组

不要从数组中delete 。请改用Array.prototype.splice 。

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

长版

JavaScript是一种OOP语言，因此所有内容都是一个对象，包括arrays 。因此，我觉得有必要指出一个特别的警告。

在数组中，与普通的旧对象不同，使用delete以null的形式在垃圾后面留下垃圾，从而在数组中创建一个“空洞”。

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

如您所见， delete并非总是可以像预期的那样进行。该值将被覆盖，但不会重新分配内存。也就是说， array[4]不会重定位到array[3] 。与Array.prototype.unshift相反，后者在数组的开头插入一个元素并将所有内容向上移动（ array[0]变为array[1]等）。

老实说，除了设置为null ，而不是undefined ，可呈现为合法怪异-这种行为并不奇怪，因为delete是一元运算符，如typeof ，也就是煮到语言和不应该照顾关于它所使用的对象的类型，而Array是Object的子类，具有专门用于处理数组的方法。因此，没有充分的理由delete来准备特殊情况以重新移动阵列，因为那样只会因不必要的工作而减慢速度。回想起来，我的期望是不现实的。

当然，这确实让我感到惊讶。因为我写这是为了证明我的运动反对“空垃圾”：

忽略null固有的危险和问题以及浪费的空间，如果数组需要精确，则可能会出现问题。

这是摆脱了可怕的理由null S-- null只危险的，如果使用不当，它没有任何与“精确”。您不应该从数组中delete的真正原因是留下乱七八糟的数据结构是草率且容易出错的。

接下来是一个人为scenario绕的人为场景，因此，如果需要，您可以跳至解决方案部分。我离开本节的唯一原因是，我认为某些人可能认为这很有趣，并且我不想成为发布“搞笑”答案然后随后删除所有“搞笑”内容的“那个人” 。

...这很愚蠢，我知道。

人为和漫长的PDP-11方案

例如，假设您正在创建一个使用JSON序列化的Web应用程序，以将用于“选项卡”的数组存储在字符串中（本例中为localStorage ）。我们还说，代码在绘制到屏幕时使用数组成员的数字索引为它们“添加标题”。您为什么要这样做，而不仅仅是存储“标题”？因为... 原因。
好吧，让我们只想说，你想在这个用户是谁运行UNIX 1960年运行的PDP-11小型机请求节省内存，写了他自己的基于Elinks-，JavaScript的标准，行式打印机友好的浏览器因为X11是不可能的。
除了越来越愚蠢的边缘情况之外，在所述阵列上使用delete将导致null污染阵列，并可能稍后导致应用程序中的错误。而且，如果您检查是否为null ，它将直接跳过数字，从而导致选项卡呈现为[1] [2] [4] [5] ... 。
if (array[index] == null) continue; else title = (index + 1).toString(); /* 0 -> "1" * 1 -> "2" * 2 -> (nothing) * 3 -> "4" */
是的，那绝对不是您想要的。
现在，您可以保留第二个迭代器，如j ，仅在从数组中读取有效值时才递增。但这并不能完全解决null问题，您仍然必须请那个巨魔 PDP-11用户使用。 las，他的计算机没有足够的内存来容纳最后一个整数_{（不要问他如何处理可变宽度数组...）} 。
因此，他很生气地向您发送了一封电子邮件：
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
大约现在，您正处于智慧的尽头。这个家伙一直在抱怨您的应用程序不停，并且您想告诉他闭嘴并得到一台更好的计算机。

解决方案： `Array.prototype.splice`

幸运的是，数组确实具有删除索引和重新分配内存的专用方法： Array.prototype.splice() 。您可以这样写：

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

就像那样，您使PDP-11先生感到高兴。万岁！ _{（不过，我还是告诉他...）}

Array.prototype.slice与Array.prototype.slice

我觉得有必要指出这两个相似命名的函数之间的区别，因为它们都很有用。

Array.prototype.splice（start，n）

.splice()数组，并返回删除的索引。从索引index start ，对数组进行切片，对n元素进行切片。如果未指定n，则将start之后的整个数组切出（ n = array.length - start ）。

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

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

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice（开始，结束）

.slice()是非破坏性的，并返回包含所指示的索引从一个新的数组start到end 。如果未指定end ，则其行为与.splice()相同（ end = array.length ）。行为有些棘手，因为出于某种原因， end索引从1而不是0开始。我不知道为什么这样做，但是事实就是如此。同样，如果end <= start ，则结果为空数组。

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

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

这实际上不是正在发生的事情，但是更容易想到这种方式。根据MDN，这是实际发生的情况：

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

由end指定的索引仅从切片中排除。括号中的索引指示要切的内容。无论哪种方式，行为都不是直观的，并且势必会造成一定比例的一次性错误，因此您可能会发现使包装函数更紧密地模拟.splice()的行为.splice() ：

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

请注意，包装函数的类型非常严格，如果禁用任何内容，则返回null 。这包括放入类似"3"的字符串。程序员要勤于类型。这是为了鼓励良好的编程习惯。

有关`is_array()`更新

这是关于以下代码段（现已删除）的：

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

事实证明，实际上存在一种内置方法来判断数组是否确实是数组，这就是ECMAScript 5（2009年12月）中引入的Array.isArray() ）。我在寻找是否有一个问题来询问对象数组时发现了这一点，以查看是否有比我的解决方案更好的解决方案，或者是否有没有比我的解决方案更好的解决方案。因此，如果您使用的JavaScript版本早于ECMA 5，则可以使用polyfill。但是，我强烈建议不要使用is_array()函数，因为继续支持旧版本的JavaScript意味着继续支持实现旧版本JavaScript的浏览器，这意味着鼓励使用不安全的软件，并使用户面临遭受恶意软件威胁的危险。因此，请使用Array.isArray() 。使用let和const 。使用添加到该语言的新功能。不要使用供应商前缀。从您的网站中删除该IE polyfill废话。删除XHTML <!CDATA[[...废话，也废话了–我们在2014年改用HTML5。]每个人越早撤回对那些旧的/深奥的浏览器的支持，浏览器供应商实际上就越早遵循Web标准并接受新技术，因此我们可以尽快进入更安全的网络。

#2楼

像这样：

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语句，“ 了解删除”

#3楼

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

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

#4楼

您在问题标题中使用的术语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（）

#5楼

操作员`delete`异常缓慢！

看基准

删除是删除对象属性而没有任何剩余物的唯一正确方法，但与“替代”设置object[key] = undefined相比，它的工作速度要慢约100倍 。

此替代方法不是此问题的正确答案！但是，如果谨慎使用它，则可以大大加快某些算法的速度。如果您正在使用delete in循环，并且在性能方面遇到问题，请阅读详细说明。

什么时候应该使用`delete`和何时将值设置为`undefined` ？

一个对象可以看作是一组键值对。我所说的“值”是连接到该“键”的原始对象或对其他对象的引用。

当将结果对象传递给您无法控制的代码时（或者不确定您的团队或您自己时） ，请使用delete

它从哈希图中删除密钥 。

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

当您关心性能时，请使用设置为undefined

键保留在哈希图中的位置 ，仅将值替换为undefined 。可以理解， for..in循环仍将在该键上进行迭代。

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

使用此方法，并非所有确定属性存在的方法都能按预期工作。

但是，此代码：

object.field === undefined

这两种方法的行为相同。

测验

总而言之，差异都是关于确定属性存在的方式以及for..in循环的。

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. *');

当心内存泄漏！

尽管使用obj[prop] = undefined比delete obj[prop]快，但另一个重要的考虑因素是obj[prop] = undefined可能并不总是合适的。 delete obj[prop]从obj删除prop并从内存中删除它，而obj[prop] = undefined只是将prop的值设置为undefined ，从而使prop仍保留在内存中。因此，在创建和删除许多键的情况下，使用obj[prop] = undefined可能会强制执行昂贵的内存协调（导致页面冻结），并可能导致内存不足错误。检查以下代码。

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

在上面的代码中，只需执行nodeRecords[i][lastTime] = undefined; 因为每个动画帧都会导致大量内存泄漏。每帧，所有65536个DOM元素将占用另一个65536个单独的插槽，但是之前的65536个插槽将仅设置为undefined，这会使它们挂在内存中。继续，尝试在控制台中运行以上代码并亲自查看。强制执行内存不足错误后，请尝试再次运行它，但以下版本的代码使用delete运算符代替。

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

如上面的代码片段所示，对于delete运算符，有一些罕见的适当用例。但是，不必过多担心此问题。这将成为具有长寿命对象的问题，这些对象会不断向其添加新密钥。在任何其他情况下（在实际编程中几乎是所有情况），最合适的是使用obj[prop] = undefined 。本部分的主要目的只是引起您的注意，以便在极少数情况下确实在代码中成为问题，然后您可以更轻松地理解问题，因此不必浪费时间剖析代码来查找并了解这个问题。

并不总是设置为`undefined`

Javascript值得考虑的一个方面是多态性。多态是指分配相同的变量/对象中的插槽不同的类型，如下所示。

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

但是，多态数组存在两个无法解决的主要问题：

它们速度慢且内存效率低下。当访问特定的索引时，浏览器不仅要获取数组的全局类型，还必须基于每个索引来获取类型，从而每个索引都存储该类型的其他元数据。
一旦是多态的，总是多态的。将数组设为多态时，无法在Webkit浏览器中撤消多态。因此，即使将多态数组还原为非多态数组，浏览器仍会将其存储为多态数组。

人们可能会将多态性比作成瘾。乍一看，它似乎非常有利可图：漂亮的蓬松代码。然后，编码人员将其数组引入多态药物。瞬间，多态数组变得效率降低，并且因为它被麻醉了，所以永远无法达到以前的效率。为了使这种情况与现实生活相关联，可卡因上的某人甚至可能无法操作简单的门把手，更不用说能够计算PI的数字了。同样，多态性药物阵列不可能像单态阵列那样高效。

但是，毒品旅行类比与delete操作有何关系？答案位于上面代码段的最后一行代码中。因此，这次要重新检查一下。

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

观察一下。 bar[1] = ""不会强制多态性，而bar[1] = undefined可以。因此，应该始终尽可能地为其对象使用相应的类型，以免偶然导致多态。一个这样的人可以使用以下列表作为一般参考，以帮助他们前进。但是，请不要明确使用以下想法。相反，请使用适用于您的代码的任何方法。

当使用类型为布尔基元的数组/变量时，请使用false或undefined作为空值。虽然最好避免不必要的多态，但是重写所有代码以明确禁止它可能实际上会导致性能下降。使用共同的判断！
使用类型为数字基元的数组/变量时，请使用0作为空值。请注意，内部有两种类型的数字：快速整数（包括2147483647至-2147483648）和慢速浮点双打（除NaN和Infinity之外的任何数字）。将整数降级为双精度数时，不能将其提升回整数。
当使用类型为字符串基元的数组/变量时，请使用""作为空值。
使用符号时，请等待，为什么要使用符号？！？！符号对性能不利。可以将所有编程为使用符号的程序重新编程为不使用符号，从而可以使没有符号的代码更快。符号实际上只是超级无效的糖。
使用其他任何东西时，请使用null 。

但是，请注意！现在不要突然开始使用所有预先存在的代码执行此操作，因为这很可能会破坏此类预先存在的代码和/或引入奇怪的错误。而是需要从一开始就实施这种有效的做法，并且在转换现有代码时，建议您对所有与之相关的行进行两次，三次，四次检查，因为尝试将旧代码升级为这种新做法可能是冒险，因为它是有益的。

#6楼

另一种选择是使用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() 。

#7楼

这里有很多很好的答案，但我只是想提醒一下，在使用delete删除JavaScript中的属性时，通常最好先检查该属性是否存在以防止错误。

例如

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

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

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

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

#8楼

这篇文章很老，我发现它很有帮助，所以我决定分享我写的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"}

#9楼

删除运算符是最好的方法。

一个实时示例显示：

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.

#10楼

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运算符）将返回false 。如果property是可配置的，则即使property不存在，它也会返回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

#11楼

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

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

#12楼

假设您有一个看起来像这样的对象：

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']; 。

删除数组索引

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

如果您知道工作人员的索引，则只需执行以下操作：

Hogwarts.staff.splice(3, 1);

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

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

注意

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

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

如果要尝试此操作，可以使用此Fiddle作为起点。

#13楼

您可以简单地使用delete关键字delete对象的任何属性。

例如：

var obj = {key1:"val1",key2:"val2",key3:"val3"}

要删除任何属性，例如key1 ，请使用delete关键字，如下所示：

delete obj.key1

或者，您也可以使用类似数组的符号：

delete obj[key1]

参考： MDN 。

#14楼

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

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

#15楼

请尝试以下方法。将Object属性值分配给undefined 。然后将对象stringify并parse 。

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

#16楼

老问题，现代答案。使用对象分解（ 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);

您可以在Babel试用版编辑器中看到它的运行情况。

编辑：

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

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

#17楼

使用ramda＃dissoc，您将获得一个不带regex属性的新对象：

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

您还可以使用其他功能达到相同的效果-省略，选择，...

#18楼

另一种解决方案，使用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);

#19楼

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

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/zh-CN/docs/Web/JavaScript/Reference/Operators/delete

#20楼

尝试这个

delete myObject['key'];

#21楼

您好，您可以尝试这种简单的排序

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

#22楼

丹的断言“删除”非常缓慢，他发布的基准测试受到质疑。因此，我自己在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

请注意，我有意在一个循环中执行了多个“删除”操作，以最大程度地减少其他操作引起的影响。

#23楼

使用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}

#24楼

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

#25楼

考虑创建没有"regex"属性的新对象，因为原始对象始终可以被程序的其他部分引用。因此，您应该避免对其进行操作。

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

#26楼

JavaScript中的属性移除

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

您要定位的ECMAScript版本
您要删除其属性的对象类型范围以及需要省略的属性名称类型（仅字符串？符号？从任意对象映射的引用弱？这些年来，JavaScript都是属性指针的类型）
您和您的团队使用的编程精神/模式。您是否偏爱功能性方法，并且团队中的突变是根深蒂固的，还是您采用了狂野西部突变的面向对象技术？
您是要使用纯JavaScript实现这一目标，还是愿意并能够使用第三方库？

回答完这四个查询后，为了满足您的目标，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"

#27楼

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

#28楼

使用ES6：

（解构+传播运算符）

const myObject = {
    regex: "^http://.*",
    b: 2,
    c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }

#29楼

传播语法（ES6）

对于需要它的人

要在该线程中完成@Koen答案，如果您要使用传播语法删除动态变量，可以这样进行：

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

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

扩展答案 😇
有几种常见的方法可以从对象中删除属性。
每个人都有自己的优缺点（请检查此性能比较）：

删除运算符
易读且简短，但是，如果您要对大量对象进行操作，则可能不是最佳选择，因为它的性能未得到优化。

delete obj[key];

重新分配
比delete快2倍以上，但是不会删除该属性，并且可以对其进行迭代。

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

点差算子
该ES6运算符使我们可以返回一个全新的对象（不包括任何属性），而无需更改现有对象。不利的一面是，它的性能比上述更差，因此当您需要一次删除许多属性时，建议不要使用它。

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

#30楼

您可以将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://.*" }

#31楼

克隆没有属性的对象：

例如：

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

而且我们需要删除“ a”。

1.带有明确的道具键：

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

2.带可变道具键：

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

3.酷箭头功能😎：

const removePropery = (propKey, { [propKey]: propValue, ...rest }) => rest;

object = removePropery('a', object);

4.对于多个属性

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 }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：pasv_address 设置内外网分开 parsec局域网

下一篇：获取数据流按照用户操作并统计每个用户不同操作的实时记录次数使用flink还是spa 获取数据的基本途径

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯