blocks|key|826925|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|826926|var+myObject+=+{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};
++++
delete+myObject.regex;

console.log+(+myObject.regex);+//+logs:+undefined|code-block|syntax|javascript|826927|826928|这在Firefox和Internet+Explorer中都有效，我认为它在所有其他浏览器中也有效。|826929|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|M|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined</code></pre>
</div>
</div>
</p>

<p>This works in Firefox and Internet&nbsp;Explorer, and I think it works in all others.</p>


blocks|key|5395721|text|要从对象中删除属性(改变对象)，可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5395722|delete+myObject.regex;
//+or,
delete+myObject['regex'];
//+or,
var+prop+=+"regex";
delete+myObject[prop];|code-block|syntax|javascript|5395723|演示|5395724|var+myObject+=+{
++++"ircEvent":+"PRIVMSG",
++++"method":+"newURI",
++++"regex":+"%5Ehttp://.*"
};
delete+myObject.regex;

console.log(myObject);|5395725|​|5395726|对于任何有兴趣了解更多信息的人，Stack+Overflow用户kangax在他们的博客上写了一篇关于delete语句的令人难以置信的深入博客文章。强烈推荐。|offset|length|style|CODE|5395727|如果你想要一个新的对象，除了一些键之外，所有的键都是原来的，你可以使用destructuring。|5395728|5395729|let+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*"
};

const+{regex,+...newObj}+=+myObject;

console.log(newObj);+++//+has+no+'regex'+key
console.log(myObject);+//+remains+unchanged|5395730|5395731|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/130652/kangax|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#object_destructuring^0|0|0|0|0|0|1F|6|W|6|0|0|Z|D|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@$O|1E|P|1F|Q|R]]|9|@$O|1G|P|1H|1|1I]]|A|$]]|$1|S|3|T|5|6|7|1J|8|@]|9|@$O|1K|P|1L|1|1M]]|A|$]]|$1|U|3|H|5|6|7|1N|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|X|3|L|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

<p>To remove a property from an object (mutating the object), you can do it like this:</p>
<pre><code>delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = &quot;regex&quot;;
delete myObject[prop];
</code></pre>
<p>Demo
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
delete myObject.regex;

console.log(myObject);</code></pre>
</div>
</div>
</p>
<p>For anyone interested in reading more about it, Stack Overflow user <a href="https://stackoverflow.com/users/130652/kangax">kangax</a> has written an incredibly in-depth blog post about the <code>delete</code> statement on their blog, <em><a href="http://perfectionkills.com/understanding-delete/" rel="noreferrer">Understanding delete</a></em>. It is highly recommended.</p>
<p>If you'd like a <em>new</em> object with all the keys of the original except some, you could use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#object_destructuring" rel="noreferrer">destructuring</a>.</p>
<p>Demo
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

const {regex, ...newObj} = myObject;

console.log(newObj);   // has no 'regex' key
console.log(myObject); // remains unchanged</code></pre>
</div>
</div>
</p>


blocks|key|3139816|text|delete运算符用于从对象中删除属性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3139817|const+obj+=+{+foo:+"bar"+}
delete+obj.foo
obj.hasOwnProperty("foo")+//+false|code-block|syntax|javascript|3139818|请注意，对于数组，这与删除元素不同。要从数组中删除元素，请使用Array#splice或Array#pop。例如：|3139819|arr+//+[0,+1,+2,+3,+4]
arr.splice(3,1);+//+3
arr+//+[0,+1,+2,+4]|3139820|详细信息|3139821|JavaScript中的delete与C和C%2B%2B中的关键字具有不同的功能:它不直接释放内存。相反，它的唯一目的是从对象中删除属性。|3139822|对于数组，删除对应于索引的属性将创建稀疏数组(即，一个带有“洞”的数组)。大多数浏览器将这些缺失的数组索引表示为“空”。|3139823|var+array+=+[0,+1,+2,+3]
delete+array[2]+//+[0,+1,+empty,+3]|3139824|请注意，delete不会将array[3]重新定位到array[2]。|3139825|JavaScript中不同的内置函数以不同的方式处理稀疏数组。|3139826|3139827|for...in将完全跳过空索引。|unordered-list-item|3139828|传统的for循环将为索引处的值返回undefined。|3139829|任何使用Symbol.iterator的方法都将为索引处的值返回undefined，D27将简单地跳过缺少的索引。|3139830|3139831|因此，delete运算符不应该用于从数组中删除元素的常见用例。数组有一个专门的方法来删除元素和重新分配内存：Array#splice()和Array#pop。|3139832|Array#splice(start[，deleteCount[，item1[，item2，...])|3139833|Array#splice会改变数组，并返回所有删除的索引。deleteCount元素从索引start中删除，而item1,+item2...+itemN从索引start插入到数组中。如果省略deleteCount，则startIndex中的元素将被删除到数组的末尾。|3139834|let+a+=+[0,1,2,3,4]
a.splice(2,2)+//+returns+the+removed+elements+[2,3]
//+...and+`a`+is+now+[0,1,4]|3139835|在Array.prototype上还有一个名称类似但不同的函数：Array#slice。|3139836|Array#slice([begin，end])|3139837|Array#slice是非破坏性的，它返回一个包含从start到end的指定索引的新数组。如果未指定end，则默认为数组的末尾。如果end为正，则指定要停止的从零开始的non-inclusive索引。如果end为负，则通过从数组末尾向后计数来指定要停止的索引(例如。-1将省略最终索引)。如果为end+<=+start，则结果为空数组。|BOLD|3139838|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]|3139839|Array#pop|3139840|Array#pop从数组中删除最后一个元素，并返回该元素。此操作更改数组的长度。|3139841|entityMap^0|0|6|0|0|V|C|18|9|0|0|0|C|6|0|0|0|4|6|D|8|Q|8|0|0|0|0|8|0|3|3|H|9|0|4|F|W|9|16|F|0|0|0|27|0|0|1F|0|0|3P|0|0|0|18|0|0|O|0|0|4O|2C|D|0|0|0|9|0|0|14|0^^$0|@$1|2|3|4|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|26|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|2A|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2J|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]|$1|11|3|12|5|13|7|2L|8|@$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|14|3|15|5|13|7|2O|8|@$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|16|3|17|5|13|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|18|3|-4|5|6|7|30|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|31|8|@$9|32|A|33|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|34|8|@$9|35|A|36|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|37|8|@$9|38|A|39|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|H|7|3A|8|@]|D|@]|E|$I|J]]|$1|1H|3|1I|5|6|7|3B|8|@$9|3C|A|3D|B|C]]|D|@]|E|$]]|$1|1J|3|1K|5|6|7|3E|8|@$9|3F|A|3G|B|C]]|D|@]|E|$]]|$1|1L|3|1M|5|6|7|3H|8|@$9|3I|A|3J|B|C]|$9|3K|A|3L|B|1N]]|D|@]|E|$]]|$1|1O|3|1P|5|H|7|3M|8|@]|D|@]|E|$I|J]]|$1|1Q|3|1R|5|6|7|3N|8|@$9|3O|A|3P|B|C]]|D|@]|E|$]]|$1|1S|3|1T|5|6|7|3Q|8|@$9|3R|A|3S|B|C]]|D|@]|E|$]]|$1|1U|3|-4|5|6|7|3T|8|@]|D|@]|E|$]]]|1V|$]]

<p>The <code>delete</code> operator is used to remove properties from objects.</p>

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

<p>Note that, for arrays, <strong>this is not the same as removing an element</strong>. To remove an element from an array, use <code>Array#splice</code> or <code>Array#pop</code>. For example:</p>

<pre><code>arr // [0, 1, 2, 3, 4]
arr.splice(3,1); // 3
arr // [0, 1, 2, 4]
</code></pre>

<h1>Details</h1>

<p><code>delete</code> in JavaScript has a different function to that of the keyword in C and C++: it does not directly free memory. Instead, its sole purpose is to remove properties from objects.</p>

<p>For arrays, deleting a property corresponding to an index, creates a sparse array (ie. an array with a "hole" in it). Most browsers represent these missing array indices as "empty".</p>

<pre><code>var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]
</code></pre>

<p>Note that <code>delete</code> does not relocate <code>array[3]</code> into <code>array[2]</code>.</p>

<p>Different built-in functions in JavaScript handle sparse arrays differently.</p>

<ul>
<li><p><code>for...in</code> will skip the empty index completely. </p></li>
<li><p>A traditional <code>for</code> loop will return <code>undefined</code> for the value at the index.</p></li>
<li><p>Any method using <code>Symbol.iterator</code> will return <code>undefined</code> for the value at the index.</p></li>
<li><p><code>forEach</code>, <code>map</code> and <code>reduce</code> will simply skip the missing index.</p></li>
</ul>

<p>So, the <code>delete</code> operator should not be used for the common use-case of removing elements from an array. Arrays have a dedicated methods for removing elements and reallocating memory: <code>Array#splice()</code> and <code>Array#pop</code>.</p>

<h2>Array#splice(start[, deleteCount[, item1[, item2[, ...]]]])</h2>

<p><code>Array#splice</code> mutates the array, and returns any removed indices. <code>deleteCount</code> elements are removed from index <code>start</code>, and <code>item1, item2... itemN</code> are inserted into the array from index <code>start</code>. If <code>deleteCount</code> is omitted then elements from startIndex are removed to the end of the array.</p>

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

<p>There is also a similarly named, but different, function on <code>Array.prototype</code>: <code>Array#slice</code>.</p>

<h2>Array#slice([begin[, end]])</h2>

<p><code>Array#slice</code> is non-destructive, and returns a new array containing the indicated indices from <code>start</code> to <code>end</code>. If <code>end</code> is left unspecified, it defaults to the end of the array. If <code>end</code> is positive, it specifies the zero-based <strong>non-inclusive</strong> index to stop at. If <code>end</code> is negative it, it specifies the index to stop at by counting back from the end of the array (eg. -1 will omit the final index). If <code>end &lt;= start</code>, the result is an empty array.</p>

<pre><code>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]
</code></pre>

<h1>Array#pop</h1>

<p><code>Array#pop</code> removes the last element from an array, and returns that element. This operation changes the length of the array.</p>


blocks|key|5395971|text|您在问题标题中使用的术语“从JavaScript对象中删除属性”可以有一些不同的解释。一种是将它从整个内存和对象键列表中删除，另一种是将其从对象中删除。正如在其他一些答案中所提到的，delete关键字是主要部分。假设您的对象如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5395972|myJSONObject+=+{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};|code-block|syntax|javascript|5395973|如果您这样做了：|5395974|console.log(Object.keys(myJSONObject));|5395975|结果将是：|5395976|["ircEvent",+"method",+"regex"]|5395977|您可以从对象关键点中删除该特定关键点，如下所示：|5395978|delete+myJSONObject["regex"];|5395979|那么使用Object.keys(myJSONObject)的对象关键字将是：|5395980|["ircEvent",+"method"]|5395981|但重点是，如果你关心内存，并且你想从内存中删除整个对象，建议在删除键之前将其设置为null：|5395982|myJSONObject["regex"]+=+null;
delete+myJSONObject["regex"];|5395983|这里的另一个要点是要小心对同一对象的其他引用。例如，如果创建一个变量，如下所示：|5395984|var+regex+=+myJSONObject["regex"];|5395985|或者将其作为指向另一个对象的新指针添加，如下所示：|5395986|var+myOtherObject+=+{};
myOtherObject["regex"]+=+myJSONObject["regex"];|5395987|然后，即使您将其从对象myJSONObject中删除，该特定对象也不会从内存中删除，因为regex变量和myOtherObject["regex"]仍然具有它们的值。那么我们如何才能确定地从内存中移除对象呢？|5395988|答案是删除你的代码中的所有引用，指向那个对象，并且不使用语句来创建对该对象的新引用。关于var语句的最后一点，是我们通常面临的最关键的问题之一，因为使用var语句会防止创建的对象被删除。|BOLD|5395989|这意味着在这种情况下，您将无法删除该对象，因为您已经通过var语句创建了regex变量，如果您这样做了：|5395990|delete+regex;+//False|5395991|结果将是false，这意味着您的delete语句没有像您预期的那样被执行。但是，如果您以前没有创建过该变量，并且只有myOtherObject["regex"]作为最后一个现有引用，那么只需删除它就可以做到这一点：|5395992|myOtherObject["regex"]+=+null;
delete+myOtherObject["regex"];|5395993|换句话说，只要代码中没有指向JavaScript对象的引用，该对象就会被终止。|5395994|5395995|更新：|5395996|感谢@AgentME：|5395997|5395998|在删除属性之前将其设置为null不会完成任何操作(除非对象已被Object.seal密封并且删除失败。除非您特别尝试，否则通常不会出现这种情况)。|blockquote|5395999|5396000|5396001|要获取有关Object.seal的更多信息，请访问：Object.seal()|5396002|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal^0|2J|6|0|0|0|0|0|0|0|0|4|P|0|0|0|0|0|0|0|0|B|C|18|5|1G|M|0|P|C|18|3|24|3|0|S|3|10|5|0|0|4|5|1M|M|0|0|0|13|0|0|0|3|0|0|0|0|0|0|5|B|Q|D|0|0^^$0|@$1|2|3|4|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|2G|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|2H|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|2I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2K|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|2L|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|2P|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|12|3|13|5|H|7|2R|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|2S|8|@]|D|@]|E|$]]|$1|16|3|17|5|H|7|2T|8|@]|D|@]|E|$I|J]]|$1|18|3|19|5|6|7|2U|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|2V|8|@]|D|@]|E|$I|J]]|$1|1C|3|1D|5|6|7|2W|8|@$9|2X|A|2Y|B|C]|$9|2Z|A|30|B|C]|$9|31|A|32|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|33|8|@$9|34|A|35|B|1G]|$9|36|A|37|B|C]|$9|38|A|39|B|C]]|D|@]|E|$]]|$1|1H|3|1I|5|6|7|3A|8|@$9|3B|A|3C|B|C]|$9|3D|A|3E|B|C]]|D|@]|E|$]]|$1|1J|3|1K|5|H|7|3F|8|@]|D|@]|E|$I|J]]|$1|1L|3|1M|5|6|7|3G|8|@$9|3H|A|3I|B|C]|$9|3J|A|3K|B|C]]|D|@]|E|$]]|$1|1N|3|1O|5|H|7|3L|8|@]|D|@]|E|$I|J]]|$1|1P|3|1Q|5|6|7|3M|8|@$9|3N|A|3O|B|1G]]|D|@]|E|$]]|$1|1R|3|-4|5|6|7|3P|8|@]|D|@]|E|$]]|$1|1S|3|1T|5|6|7|3Q|8|@$9|3R|A|3S|B|1G]]|D|@]|E|$]]|$1|1U|3|1V|5|6|7|3T|8|@]|D|@]|E|$]]|$1|1W|3|-4|5|6|7|3U|8|@]|D|@]|E|$]]|$1|1X|3|1Y|5|1Z|7|3V|8|@]|D|@]|E|$]]|$1|20|3|-4|5|6|7|3W|8|@]|D|@]|E|$]]|$1|21|3|-4|5|6|7|3X|8|@]|D|@]|E|$]]|$1|22|3|23|5|6|7|3Y|8|@$9|3Z|A|40|B|C]]|D|@$9|41|A|42|1|43]]|E|$]]|$1|24|3|-4|5|6|7|44|8|@]|D|@]|E|$]]]|25|$26|$5|27|28|29|E|$2A|2B]]]]

<p>The term you have used in your question title, <em>Remove a property from a JavaScript object</em>, can be interpreted in some different ways. The one is to remove it for whole the memory and the list of object keys or the other is just to remove it from your object. As it has been mentioned in some other answers, the <code>delete</code> keyword is the main part. Let's say you have your object like:</p>
<pre><code>myJSONObject = {&quot;ircEvent&quot;: &quot;PRIVMSG&quot;, &quot;method&quot;: &quot;newURI&quot;, &quot;regex&quot;: &quot;^http://.*&quot;};
</code></pre>
<p>If you do:</p>
<pre><code>console.log(Object.keys(myJSONObject));
</code></pre>
<p>the result would be:</p>
<pre><code>[&quot;ircEvent&quot;, &quot;method&quot;, &quot;regex&quot;]
</code></pre>
<p>You can delete that specific key from your object keys like:</p>
<pre><code>delete myJSONObject[&quot;regex&quot;];
</code></pre>
<p>Then your objects key using <code>Object.keys(myJSONObject)</code> would be:</p>
<pre><code>[&quot;ircEvent&quot;, &quot;method&quot;]
</code></pre>
<p>But the point is if you care about memory and you want to whole the object gets removed from the memory, it is recommended to set it to null before you delete the key:</p>
<pre><code>myJSONObject[&quot;regex&quot;] = null;
delete myJSONObject[&quot;regex&quot;];
</code></pre>
<p>The other important point here is to be careful about your other references to the same object. For instance, if you create a variable like:</p>
<pre><code>var regex = myJSONObject[&quot;regex&quot;];
</code></pre>
<p>Or add it as a new pointer to another object like:</p>
<pre><code>var myOtherObject = {};
myOtherObject[&quot;regex&quot;] = myJSONObject[&quot;regex&quot;];
</code></pre>
<p>Then even if you remove it from your object <code>myJSONObject</code>, that specific object won't get deleted from the memory, since the <code>regex</code> variable and <code>myOtherObject[&quot;regex&quot;]</code> still have their values. Then how could we remove the object from the memory for sure?</p>
<p>The answer would be to <strong>delete all the references you have in your code, pointed to that very object</strong> and also <strong>not use <code>var</code> statements to create new references to that object</strong>. This last point regarding <code>var</code> statements, is one of the most crucial issues that we are usually faced with, because using <code>var</code> statements would prevent the created object from getting removed.</p>
<p>Which means in this case you won't be able to remove that object because you have created the <code>regex</code> variable via a <code>var</code> statement, and if you do:</p>
<pre><code>delete regex; //False
</code></pre>
<p>The result would be <code>false</code>, which means that your delete statement haven't been executed as you expected. But if you had not created that variable before, and you only had <code>myOtherObject[&quot;regex&quot;]</code> as your last existing reference, you could have done this just by removing it like:</p>
<pre><code>myOtherObject[&quot;regex&quot;] = null;
delete myOtherObject[&quot;regex&quot;];
</code></pre>
<p><strong>In other words, a JavaScript object gets killed as soon as there is no reference left in your code pointed to that object.</strong></p>
<hr />
<p><strong>Update:</strong></p>
<p>Thanks to @AgentME:</p>
<blockquote>
<p>Setting a property to null before deleting it doesn't accomplish
anything (unless the object has been sealed by Object.seal and the
delete fails. That's not usually the case unless you specifically
try).</p>
</blockquote>
<p>To get more information on <code>Object.seal</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal" rel="noreferrer">Object.seal()</a></p>


blocks|key|3985000|text|JavaScript中的对象可以看作是键和值之间的映射。delete运算符用于一次删除一个键，这些键通常称为对象属性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3985001|​|3985002|var+obj+=+{
++myProperty:+1++++
}
console.log(obj.hasOwnProperty('myProperty'))+//+true
delete+obj.myProperty
console.log(obj.hasOwnProperty('myProperty'))+//+false|code-block|syntax|javascript|3985003|3985004|delete运算符不直接释放内存，它不同于简单地将null或undefined的值赋给属性，因为属性本身是从对象中删除的。注意，如果一个已删除属性的值是一个引用类型(一个对象)，并且程序的另一部分仍然持有对该对象的引用，那么该对象当然不会被垃圾回收，直到对它的所有引用都消失为止。|3985005|delete将仅在其描述符将其标记为可配置的属性上工作。|3985006|entityMap^0|S|6|0|0|0|0|0|6|P|4|U|9|0|0|6|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|X|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|S|$]]

<p>Objects in JavaScript can be thought of as maps between keys and values. The <code>delete</code> operator is used to remove these keys, more commonly known as object properties, one at a time.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var obj = {
  myProperty: 1    
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false</code></pre>
</div>
</div>
</p>

<p>The <code>delete</code> operator does not directly free memory, and it differs from simply assigning the value of <code>null</code> or <code>undefined</code> to a property, in that the property <em>itself</em> is removed from the object. Note that if the <em>value</em> of a deleted property was a reference type (an object), and another part of your program still holds a reference to that object, then that object will, of course, not be garbage collected until all references to it have disappeared.</p>

<p><code>delete</code> will only work on properties whose descriptor marks them as configurable.</p>


blocks|key|822664|text|另一种选择是使用Underscore.js库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|822665|请注意，_.pick()和_.omit()都返回对象的副本，并且不直接修改原始对象。将结果赋值给原始对象应该可以做到这一点(未显示)。|style|CODE|822666|参考：link+_.pick(object，*keys)|BOLD|822667|返回对象的副本，过滤后仅包含白名单键(或有效键的数组)的值。|822668|var+myJSONObject+=+
{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};

_.pick(myJSONObject,+"ircEvent",+"method");
=>+{"ircEvent":+"PRIVMSG",+"method":+"newURI"};|code-block|syntax|javascript|822669|参考：link+_.omit(object，*keys)|822670|返回对象的副本，过滤后忽略黑名单中的键(或键数组)。|822671|var+myJSONObject+=+
{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};

_.omit(myJSONObject,+"regex");
=>+{"ircEvent":+"PRIVMSG",+"method":+"newURI"};|822672|对于数组，可以以类似的方式使用_.filter()和_.reject()。|822673|entityMap|0|LINK|mutability|MUTABLE|url|https://underscorejs.org/|1|http://underscorejs.org/#pick|2|http://underscorejs.org/#omit^0|8|D|0|0|4|8|D|8|0|8|K|3|4|1|0|0|0|8|K|3|4|2|0|0|0|F|A|Q|A|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|E|5|6|7|1F|8|@$A|1G|B|1H|F|G]|$A|1I|B|1J|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1K|8|@$A|1L|B|1M|F|J]]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|K|3|L|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1R|8|@]|9|@]|C|$P|Q]]|$1|R|3|S|5|6|7|1S|8|@$A|1T|B|1U|F|J]]|9|@$A|1V|B|1W|1|1X]]|C|$]]|$1|T|3|U|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|V|3|W|5|O|7|1Z|8|@]|9|@]|C|$P|Q]]|$1|X|3|Y|5|6|7|20|8|@$A|21|B|22|F|G]|$A|23|B|24|F|G]]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|25|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]|17|$5|12|13|14|C|$15|18]]|19|$5|12|13|14|C|$15|1A]]]]

<p>Another alternative is to use the <a href="https://underscorejs.org" rel="noreferrer">Underscore.js</a> library. </p>

<p>Note that <code>_.pick()</code> and <code>_.omit()</code> both return a copy of the object and don't directly modify the original object. Assigning the result to the original object should do the trick (not shown).</p>

<p>Reference: <a href="http://underscorejs.org/#pick" rel="noreferrer">link</a> <strong>_.pick(object, *keys)</strong></p>

<p>Return a copy of the object, filtered to only have values for the 
whitelisted keys (or array of valid keys).</p>

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

_.pick(myJSONObject, "ircEvent", "method");
=&gt; {"ircEvent": "PRIVMSG", "method": "newURI"};
</code></pre>

<p>Reference: <a href="http://underscorejs.org/#omit" rel="noreferrer">link</a> <strong>_.omit(object, *keys)</strong></p>

<p>Return a copy of the object, filtered to omit the 
blacklisted keys (or array of keys).</p>

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

_.omit(myJSONObject, "regex");
=&gt; {"ircEvent": "PRIVMSG", "method": "newURI"};
</code></pre>

<p>For arrays, <code>_.filter()</code> and <code>_.reject()</code> can be used in a similar manner. </p>


blocks|key|822700|text|这里有很多好的答案，但我只想附和一下，当使用delete删除JavaScript中的属性时，通常明智的做法是首先检查该属性是否存在，以防止出现错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|822701|E.g|822702|var+obj+=+{"property":"value",+"property2":"value"};

if+(obj+&&+obj.hasOwnProperty("property2"))+{
++delete+obj.property2;
}+else+{
++//error+handling
}|code-block|syntax|javascript|822703|由于JavaScript的动态特性，经常会出现您根本不知道属性是否存在的情况。检查obj在&&之前是否存在，也可以确保不会因为在未定义的对象上调用hasOwnProperty()函数而抛出错误。|822704|很抱歉，如果这没有添加到您的特定用例中，但我相信这是一个很好的设计，可以在管理对象及其属性时进行调整。|822705|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>There are a lot of good answers here but I just want to chime in that when using delete to remove a property in JavaScript, it is often wise to first check if that property exists to prevent errors.</p>

<p>E.g</p>

<pre><code>var obj = {"property":"value", "property2":"value"};

if (obj &amp;&amp; obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}
</code></pre>

<p>Due to the dynamic nature of JavaScript there are often cases where you simply don't know if the property exists or not. Checking if obj exists before the &amp;&amp; also makes sure you don't throw an error due to calling the hasOwnProperty() function on an undefined object.</p>

<p>Sorry if this didn't add to your specific use case but I believe this to be a good design to adapt when managing objects and their properties.</p>


blocks|key|5396343|text|这篇文章很老了，我发现它很有帮助，所以我决定分享我写的unset函数，以防其他人看到这篇文章，想一想为什么它不像PHP+unset函数那么简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5396344|之所以编写这个新的unset函数，是为了在这个hash_map中保留所有其他变量的索引。看看下面的例子，看看"test2“的索引是如何在从hash_map中删除一个值之后没有改变的。|offset|length|style|CODE|5396345|​|5396346|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%2B%2B;
++++++}+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"}|code-block|syntax|javascript|5396347|5396348|entityMap^0|0|9|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|W|8|@]|9|@]|A|$M|N]]|$1|O|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

<p>This post is very old and I find it very helpful so I decided to share the unset function I wrote in case someone else see this post and think why it's not so simple as it in PHP unset function.</p>
<p>The reason for writing this new <code>unset</code> function, is to keep the index of all other variables in this hash_map. Look at the following example, and see how the index of &quot;test2&quot; did not change after removing a value from the hash_map.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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"}</code></pre>
</div>
</div>
</p>


blocks|key|5396416|text|ECMAScript+2015+(或ES6)附带了内置的Reflect对象。可以通过调用以目标对象和属性键为参数的Reflect.deleteProperty()函数来删除对象属性：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5396417|Reflect.deleteProperty(myJSONObject,+'regex');|code-block|syntax|javascript|5396418|相当于：|5396419|delete+myJSONObject['regex'];|5396420|但如果对象的属性不可配置，则既不能使用deleteProperty函数删除，也不能使用delete操作符删除：|5396421|let+obj+=+Object.freeze({+prop:+"value"+});
let+success+=+Reflect.deleteProperty(obj,+"prop");
console.log(success);+//+false
console.log(obj.prop);+//+value|5396422|Object.freeze()使得对象的所有属性都是不可配置的(除了其他东西)。deleteProperty函数(以及delete+operator)在尝试删除其任何属性时返回false。如果属性是可配置的，则即使属性不存在，它也会返回true。|style|CODE|5396423|delete和deleteProperty的区别在于使用严格模式时：|5396424|"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|5396425|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/deleteProperty|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze|3|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete^0|S|7|0|1L|O|1|0|0|0|0|0|0|14|E|2G|5|3A|4|0|F|2|1N|F|3|0|0|6|7|E|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]|$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|F|7|1J|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1K|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1L|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1M|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1N|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1O|8|@$A|1P|B|1Q|S|T]|$A|1R|B|1S|S|T]|$A|1T|B|1U|S|T]]|9|@$A|1V|B|1W|1|1X]|$A|1Y|B|1Z|1|20]]|C|$]]|$1|U|3|V|5|6|7|21|8|@$A|22|B|23|S|T]|$A|24|B|25|S|T]]|9|@]|C|$]]|$1|W|3|X|5|F|7|26|8|@]|9|@]|C|$G|H]]|$1|Y|3|-4|5|6|7|27|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]|18|$5|11|12|13|C|$14|19]]|1A|$5|11|12|13|C|$14|1B]]]]

<p>ECMAScript 2015 (or ES6) came with built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect">Reflect</a> object. It is possible to delete object property by calling <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/deleteProperty">Reflect.deleteProperty()</a> function with target object and property key as parameters:</p>

<pre><code>Reflect.deleteProperty(myJSONObject, 'regex');
</code></pre>

<p>which is equivalent to:</p>

<pre><code>delete myJSONObject['regex'];
</code></pre>

<p>But if the property of the object is not configurable it cannot be deleted neither with deleteProperty function nor delete operator:</p>

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

<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze">Object.freeze()</a> makes all properties of object not configurable (besides other things). <code>deleteProperty</code> function (as well as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete operator</a>) returns <code>false</code> when tries to delete any of it's properties. If property is configurable it returns <code>true</code>, even if property does not exist.</p>

<p>The difference between <code>delete</code> and <code>deleteProperty</code> is when using strict mode:</p>

<pre><code>"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
</code></pre>


blocks|key|822786|text|我个人使用Underscore.js或Lodash来处理对象和数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|822787|myObject+=+_.omit(myObject,+'regex');|code-block|syntax|javascript|822788|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Underscore.js|1|https://lodash.com/^0|5|D|0|J|6|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

<p>I personally use <a href="https://en.wikipedia.org/wiki/Underscore.js" rel="noreferrer">Underscore.js</a> or <a href="https://lodash.com" rel="noreferrer">Lodash</a> for object and array manipulation:</p>

<pre><code>myObject = _.omit(myObject, 'regex');
</code></pre>


blocks|key|3985444|text|假设您有一个如下所示的对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3985445|var+Hogwarts+=+{
++++staff+:+[
++++++++'Argus+Filch',
++++++++'Filius+Flitwick',
++++++++'Gilderoy+Lockhart',
++++++++'Minerva+McGonagall',
++++++++'Poppy+Pomfrey',
++++++++...
++++],
++++students+:+[
++++++++'Hannah+Abbott',
++++++++'Katie+Bell',
++++++++'Susan+Bones',
++++++++'Terry+Boot',
++++++++'Lavender+Brown',
++++++++...
++++]
};|code-block|syntax|javascript|3985446|删除对象属性|3985447|如果您想要使用整个staff数组，正确的方法是这样做：|offset|length|style|CODE|3985448|delete+Hogwarts.staff;|3985449|或者，您也可以这样做：|3985450|delete+Hogwarts['staff'];|3985451|类似地，可以通过调用delete+Hogwarts.students;或delete+Hogwarts['students'];来删除整个学生数组。|3985452|删除数组索引|3985453|现在，如果您想删除单个教员或学生，则过程略有不同，因为这两个属性本身都是数组。|3985454|如果你知道你的员工的索引，你可以简单地这样做：|3985455|Hogwarts.staff.splice(3,+1);|3985456|如果您不知道索引，则还必须执行索引搜索：|3985457|Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva+McGonnagall')+-+1,+1);|3985458|3985459|备注|3985460|虽然从技术上讲，您可以对数组使用delete，但在稍后调用例如Hogwarts.staff.length时，使用它会导致不正确的结果。换句话说，delete将删除该元素，但不会更新length属性的值。使用delete也会弄乱你的索引。|3985461|因此，当从对象中删除值时，总是首先考虑您是在处理对象属性，还是在处理数组值，并基于此选择适当的策略。|3985462|如果您想尝试一下，可以使用作为起点。|3985463|entityMap^0|0|0|0|9|5|0|0|0|0|A|P|10|S|0|0|0|0|0|0|0|0|0|G|6|V|L|20|6|2I|6|2V|6|0|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1L|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1M|8|@$K|1N|L|1O|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1S|8|@$K|1T|L|1U|M|N]|$K|1V|L|1W|M|N]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1X|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|21|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|18|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|24|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|25|8|@$K|26|L|27|M|N]|$K|28|L|29|M|N]|$K|2A|L|2B|M|N]|$K|2C|L|2D|M|N]|$K|2E|L|2F|M|N]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1H|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]]|1I|$]]

<p>Suppose you have an object that looks like this:</p>

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

<h3>Deleting an object property</h3>

<p>If you want to use the entire <code>staff</code> array, the proper way to do this, would be to do this:</p>

<pre><code>delete Hogwarts.staff;
</code></pre>

<p>Alternatively, you could also do this:</p>

<pre><code>delete Hogwarts['staff'];
</code></pre>

<p>Similarly, removing the entire students array would be done by calling <code>delete Hogwarts.students;</code> or <code>delete Hogwarts['students'];</code>.</p>

<h3>Deleting an array index</h3>

<p>Now, if you want to remove a single staff member or student, the procedure is a bit different, because both properties are arrays themselves.</p>

<p>If you know the index of your staff member, you could simply do this:</p>

<pre><code>Hogwarts.staff.splice(3, 1);
</code></pre>

<p>If you do not know the index, you'll also have to do an index search:</p>

<pre><code>Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);
</code></pre>

<hr>

<h3>Note</h3>

<p>While you technically can use <code>delete</code> for an array, using it would result in getting incorrect results when calling for example <code>Hogwarts.staff.length</code> later on. In other words, <code>delete</code> would remove the element, but it wouldn't update the value of <code>length</code> property. Using <code>delete</code> would also mess up your indexing.</p>

<p>So, when deleting values from an object, always first consider whether you're dealing with object properties or whether you're dealing with array values, and choose the appropriate strategy based on that.</p>

<p>If you want to experiment with this, you can use <a href="http://jsfiddle.net/cb57dusv/46/"><strong>this Fiddle</strong></a> as a starting point.</p>


blocks|key|3140660|text|如果你想删除一个嵌套在对象中的属性，那么你可以使用下面的递归函数，并将该属性的路径作为第二个参数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3140661|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;
++++}
};|code-block|syntax|javascript|3140662|示例：|3140663|var+a+=+{
++++level1:{
++++++++level2:{
++++++++++++level3:+{
++++++++++++++++level4:+"yolo"
++++++++++++}
++++++++}
++++}
};

deepObjectRemove(a,+["level1",+"level2",+"level3"]);
console.log(a);

//Prints+{level1:+{level2:+{}}}|3140664|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>If you want to delete a property deeply nested in the object then you can use the following recursive function with path to the property as the second argument:</p>

<pre><code>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;
    }
};
</code></pre>

<p>Example: </p>

<pre><code>var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}
</code></pre>


blocks|key|822952|text|请尝试以下方法。将Object属性值分配给undefined。然后stringify对象和parse。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|822953|​|822954|+var+myObject+=+{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};

myObject.regex+=+undefined;
myObject+=+JSON.parse(JSON.stringify(myObject));

console.log(myObject);|code-block|syntax|javascript|822955|822956|entityMap^0|9|6|L|9|X|9|19|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|O|$]]

<p>Try the following method. Assign the <code>Object</code> property value to <code>undefined</code>. Then <code>stringify</code> the object and <code>parse</code>.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code> var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);</code></pre>
</div>
</div>
</p>


blocks|key|3985769|text|老问题，现代答案。使用对象解构，这是一个ECMAScript 6特性，它非常简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3985770|const+{+a,+...rest+}+=+{+a:+1,+b:+2,+c:+3+};|code-block|syntax|javascript|3985771|或者使用问题示例：|3985772|const+myObject+=+{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};
const+{+regex,+...newObject+}+=+myObject;
console.log(newObject);|3985773|You+can+see+it+in+action+in+the+Babel+try-out+editor.|3985774|3985775|编辑：|style|BOLD|3985776|要为同一变量重新赋值，请使用let|CODE|3985777|let+myObject+=+{"ircEvent":+"PRIVMSG",+"method":+"newURI",+"regex":+"%5Ehttp://.*"};
({+regex,+...myObject+}+=+myObject);
console.log(myObject);|3985778|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_-_ECMAScript_2015|1|https://babeljs.io/repl/#?babili=false&evaluate=true&lineWrap=true&presets=es2015,stage-0&experimental=true&loose=true&spec=false&code=const%2520myObject%2520=%2520{^0|K|C|0|0|0|0|0|0|1H|1|0|0|0|3|0|E|3|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1D|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|O|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1K|8|@$A|1L|B|1M|R|S]]|9|@]|C|$]]|$1|T|3|U|5|6|7|1N|8|@$A|1O|B|1P|R|V]]|9|@]|C|$]]|$1|W|3|X|5|F|7|1Q|8|@]|9|@]|C|$G|H]]|$1|Y|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]]]

<p>Old question, modern answer. Using object destructuring, an <a href="https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_-_ECMAScript_2015">ECMAScript&nbsp;6</a> feature, it's as simple as:</p>

<pre><code>const { a, ...rest } = { a: 1, b: 2, c: 3 };
</code></pre>

<p>Or with the questions sample:</p>

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

<p><a href="https://babeljs.io/repl/#?babili=false&amp;evaluate=true&amp;lineWrap=true&amp;presets=es2015%2Cstage-0&amp;experimental=true&amp;loose=true&amp;spec=false&amp;code=const%20myObject%20%3D%20%7B%22ircEvent%22%3A%20%22PRIVMSG%22%2C%20%22method%22%3A%20%22newURI%22%2C%20%22regex%22%3A%20%22%5Ehttp%3A%2F%2F.*%22%7D%3B%0Aconst%20%7B%20regex%2C%20...newObject%20%7D%20%3D%20myObject%3B%0Aconsole.log(newObject)%3B">You can see it in action in the Babel try-out editor.</a></p>

<hr>

<p><strong>Edit:</strong></p>

<p>To reassign to the same variable, use a <code>let</code>:</p>

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


blocks|key|5396898|text|使用ramda#dissoc，您将获得一个没有属性regex的新对象|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5396899|const+newObject+=+R.dissoc('regex',+myObject);
//+newObject+!==+myObject|code-block|syntax|javascript|5396900|你也可以使用其他函数来达到同样的效果--+omit，pick，...|5396901|entityMap|0|LINK|mutability|MUTABLE|url|http://ramdajs.com/docs/#dissoc^0|P|5|2|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<p>Using <a href="http://ramdajs.com/docs/#dissoc" rel="noreferrer">ramda#dissoc</a> you will get a new object without the attribute <code>regex</code>:</p>

<pre><code>const newObject = R.dissoc('regex', myObject);
// newObject !== myObject
</code></pre>

<p>You can also use other functions to achieve the same effect - omit, pick, ...</p>


blocks|key|3985884|text|另一种解决方案是使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3985885|​|3985886|var+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*"
};

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);|code-block|syntax|javascript|3985887|3985888|但是，它将对原始对象进行突变。如果您想在没有指定键的情况下创建一个新的对象，只需将函数赋给一个新变量，例如：|offset|length|style|BOLD|3985889|(ES6)|3985890|3985891|const+myObject+=+{
++ircEvent:+'PRIVMSG',
++method:+'newURI',
++regex:+'%5Ehttp://.*',
};

const+myNewObject+=+Object.keys(myObject).reduce((obj,+key)+=>+{
++key+!==+'regex'+?+obj[key]+=+myObject[key]+:+null;
++return+obj;
},+{});

console.log(myNewObject);|3985892|3985893|entityMap^0|0|0|0|0|11|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@$L|12|M|13|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

<p>Another solution, using <strong><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce" rel="noreferrer"><code>Array#reduce</code></a></strong>.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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);</code></pre>
</div>
</div>
</p>

<p>However, it will <strong>mutate</strong> the original object. If you want to create a new object <strong>without</strong> the specified key, just assign the reduce function to a new variable, e.g.: </p>

<p>(ES6)</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) =&gt; {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);</code></pre>
</div>
</div>
</p>


blocks|key|3985926|text|使用+delete+方法是最好的方法，根据MDN的描述，delete操作符从对象中删除属性。所以你可以简单的写下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3985927|delete+myObject.regex;
//+OR
delete+myObject['regex'];|code-block|syntax|javascript|3985928|3985929|删除运算符从对象中删除给定的属性。删除成功，返回true，否则返回false。但是，重要的是要考虑以下情况：|blockquote|3985930|3985931|3985932|3985933|如果您试图删除的属性不存在，则delete将不起任何作用，并将返回|unordered-list-item|3985934|如果对象的原型链上存在同名的属性，则在删除后，对象将使用原型链中的属性(换句话说，delete仅影响用var声明的自己的delete属性不能从全局作用域或函数的作用域中删除。|3985935|因此，delete不能删除全局范围内的任何函数(无论这是函数定义的一部分还是函数(表达式)的一部分。作为对象一部分的|3985936|函数(|3985937|3985938|全局范围)可以用delete删除。|3985939|任何用let或const声明的属性都不能从定义它们的范围中删除。无法删除不可配置的属性。这包括数学、数组、对象等内置对象的属性，以及使用Object.defineProperty().|3985940|
等方法创建为不可配置的属性|3985941|下面的代码片段给出了另一个简单的示例：|3985942|​|3985943|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|3985944|3985945|有关更多信息和查看更多示例，请访问以下链接：|3985946|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete|3985947|entityMap|0|LINK|mutability|MUTABLE|url^0|2|8|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2A|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1U|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|1Y|8|@]|D|@]|E|$]]|$1|U|3|V|5|T|7|1Z|8|@]|D|@]|E|$]]|$1|W|3|X|5|T|7|20|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|T|7|21|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|11|3|12|5|6|7|23|8|@]|D|@]|E|$]]|$1|13|3|14|5|T|7|24|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|25|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|26|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|27|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|1D|3|1A|5|6|7|29|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|2A|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|2B|8|@]|D|@$9|2C|A|2D|1|2E]]|E|$]]|$1|1I|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1H]]]]

<p>Using <strong>delete</strong> method is the best way to do that, as per MDN description, the delete operator removes a property from an object. So you can simply write:</p>

<pre><code>delete myObject.regex;
// OR
delete myObject['regex'];
</code></pre>

<blockquote>
  <p>The delete operator removes a given property from an object. On
  successful deletion, it will return true, else false will be returned.
  However, it is important to consider the following scenarios:</p>
  
  <ul>
  <li><p>If the property which you are trying to delete does not exist, delete
  will not have any effect and will return true</p></li>
  <li><p>If a property with the same name exists on the object's prototype
  chain, then, after deletion, the object will use the property from the
  prototype chain (in other words, delete only has an effect on own
  properties).</p></li>
  <li><p>Any property declared with var cannot be deleted from the global scope
  or from a function's scope.</p></li>
  <li><p>As such, delete cannot delete any functions in the global scope (whether this is part from a function definition or a function  (expression). </p></li>
  <li><p>Functions which are part of an object (apart from the<br>
  global scope) can be deleted with delete.</p></li>
  <li><p>Any property declared with let or const cannot be deleted from the scope  within which they were defined. Non-configurable properties cannot be removed. This includes properties of built-in objects like Math, Array, Object and properties that are created as non-configurable with methods like Object.defineProperty().</p></li>
  </ul>
</blockquote>

<p>The following snippet gives another simple example:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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</code></pre>
</div>
</div>
</p>

<p>For more info about and seeing more example, visit the link below:</p>

<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete" rel="noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete</a></p>


blocks|key|3985963|text|Dan's+assertion说“删除”非常慢，他发布的基准测试受到了质疑。所以我自己在Chrome59上进行了测试。看起来'delete‘大约慢了30倍：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3985964|var+iterationsTotal+=+10000000;++//+10+million
var+o;
var+t1+=+Date.now(),t2;
for+(let+i=0;+i<iterationsTotal;+i%2B%2B)+{
+++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%2B%2B)+{
+++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|code-block|syntax|javascript|3985965|请注意，我故意在一个循环周期中执行了多个“删除”操作，以最小化其他操作造成的影响。|3985966|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/208105/how-do-i-remove-a-property-from-a-javascript-object/21735614#21735614^0|0|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<p><a href="https://stackoverflow.com/questions/208105/how-do-i-remove-a-property-from-a-javascript-object/21735614#21735614">Dan's assertion</a> that 'delete' is very slow and the benchmark he posted were doubted. So I carried out the test myself in Chrome 59. It does seem that 'delete' is about 30 times slower:</p>
<pre><code>var iterationsTotal = 10000000;  // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i&lt;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&lt;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
</code></pre>
<p>Note that I purposedly carried out more than one 'delete' operations in one loop cycle to minimize the effect caused by the other operations.</p>


blocks|key|5397007|text|使用Lodash|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5397008|import+omit+from+'lodash/omit';

const+prevObject+=+{test:+false,+test2:+true};
//+Removes+test2+key+from+previous+object
const+nextObject+=+omit(prevObject,+'test2');|code-block|syntax|javascript|5397009|使用Ramda|5397010|R.omit(['a',+'d'],+{a:+1,+b:+2,+c:+3,+d:+4});+//=>+{b:+2,+c:+3}|5397011|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Lodash^0|2|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<h3 id="using-lodash-2jrs">Using <a href="https://en.wikipedia.org/wiki/Lodash" rel="nofollow noreferrer">Lodash</a></h3>
<pre><code>import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');
</code></pre>
<h3 id="using-ramda-845r">Using Ramda</h3>
<pre><code>R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=&gt; {b: 2, c: 3}
</code></pre>


blocks|key|827546|text|Object.assign()+&+Object.keys()+&+Array.map()|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827547|​|827548|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"];
++++++++}
++++}
);|code-block|syntax|javascript|827549|827550|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<h1>Object.assign() &amp; Object.keys() &amp; Array.map()</h1>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="true">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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) =&gt; {
        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) =&gt; {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
        return new_obj2;
    }
)[0];


*/


// new version!

let shaped_obj1 = Object.keys(new_obj1).forEach(
    (key, index) =&gt; {
        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) =&gt; {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
    }
);</code></pre>
</div>
</div>
</p>


blocks|key|823128|text|我也使用了Lodash+"unset"来使嵌套对象发生这种情况……这只需要编写小逻辑来获取属性键的路径，这是omit方法所期望的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|823129|以数组形式返回属性路径的|823130|方法|ordered-list-item|823131|823132|​|823133|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+%7C%7C+[];

++++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"))|code-block|syntax|javascript|823134|<div+id="output">

</div>|823135|823136|823137|然后使用Lodash+unset方法从object中删除属性。|823138|823139|823140|var+unset+=+require('lodash.unset');
unset(a,+getPathOfKey(a,+"price_index.final_price"));|823141|823142|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs/4.17.4#unset|1^0|5|E|0|0|0|0|0|0|0|0|0|0|4|C|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1F|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1H|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|1I|8|@]|9|@]|C|$O|P]]|$1|Q|3|R|5|N|7|1J|8|@]|9|@]|C|$O|P]]|$1|S|3|K|5|6|7|1K|8|@]|9|@]|C|$]]|$1|T|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]|$1|U|3|V|5|H|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|W|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|X|3|K|5|6|7|1R|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|N|7|1S|8|@]|9|@]|C|$O|P]]|$1|10|3|K|5|6|7|1T|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|1U|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]|19|$5|14|15|16|C|$17|18]]]]

<p>I have used <a href="https://lodash.com/docs/4.17.4#unset" rel="nofollow noreferrer">Lodash &quot;unset&quot;</a> to make it happen for a nested object also... only this needs to write small logic to get the path of the property key which is expected by the <em>omit</em> method.</p>
<ol>
<li>Method which returns the property path as an array</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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"))</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div id="output"&gt;

&lt;/div&gt;</code></pre>
</div>
</div>
</p>
<ol>
<li>Then just using <a href="https://lodash.com/docs/4.17.4#unset" rel="nofollow noreferrer">Lodash unset</a> method remove property from object.</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var unset = require('lodash.unset');
unset(a, getPathOfKey(a, "price_index.final_price"));</code></pre>
</div>
</div>
</p>


blocks|key|827598|text|JavaScript中的属性删除|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827599|这个页面上有许多不同的选项，不是因为大多数选项是错误的，也不是因为答案是重复的，而是因为适当的技术取决于您所处的情况以及您和/或您的团队试图完成的任务的目标。要明确回答你的问题，你需要知道：|827600|827601|您要删除的ECMAScript的版本|ordered-list-item|827602|要删除其属性的对象类型的范围以及您需要能够省略的属性名称的类型(仅字符串？符号？从任意对象映射的弱引用？多年来，这些都是JavaScript中的属性指针类型)|827603|你和你的团队使用的编程风格/模式。你喜欢函数式方法并且你的团队中禁止突变，还是你使用狂野的西方可变的面向对象的techniques?|827604|Are，你希望在纯JavaScript中实现这一点，或者你愿意并能够使用第三方库？|827605|827606|一旦这四个问题得到回答，为了满足您的目标，JavaScript中基本上有四个类别的“属性删除”可供选择。它们是：|827607|可变对象属性删除，不安全|827608|此类别用于当您想要保留/继续使用原始引用而不是在代码中使用无状态函数原理时，对对象文字或对象实例进行操作。这一类中的语法示例如下：|827609|'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|code-block|syntax|javascript|827610|这个类别是最古老、最直接、最受支持的属性删除类别。除了字符串之外，它还支持Symbol和数组索引，并且可以在除第一个发行版以外的所有JavaScript版本中工作。然而，它是可变的，这违反了一些编程原则，并具有性能影响。在non-configurable+properties+in+strict+mode上使用时，它还可能导致未捕获的异常。|offset|length|style|CODE|827611|基于Rest的字符串属性省略|827612|此类别用于在需要非可变方法且不需要考虑符号键时，以较新的ECMAScript风格对普通对象或数组实例进行操作：|827613|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+:(|827614|可变对象属性删除，安全|827615|此类别用于操作对象文字或对象实例，当您希望保留/继续使用原始引用时，同时防止在不可配置的属性上引发异常：|827616|'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|827617|此外，尽管就地更改对象不是无状态的，但您可以使用Reflect.deleteProperty的函数性质来执行delete语句不可能实现的部分应用程序和其他函数技术。|827618|基于语法的字符串属性省略|827619|827620|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+:(|827621|基于库的属性省略|827622|这一类别通常允许更大的功能灵活性，包括考虑符号&在一条语句中省略多个属性：|827623|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"|827624|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete^0|0|0|0|0|0|0|0|0|0|0|0|0|11|6|33|16|0|0|0|0|0|0|0|0|O|M|1I|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|22|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|23|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|25|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|26|8|@]|9|@]|A|$]]|$1|J|3|K|5|G|7|27|8|@]|9|@]|A|$]]|$1|L|3|M|5|G|7|28|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|2C|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|2D|8|@]|9|@]|A|$X|Y]]|$1|Z|3|10|5|6|7|2E|8|@$11|2F|12|2G|13|14]]|9|@$11|2H|12|2I|1|2J]]|A|$]]|$1|15|3|16|5|6|7|2K|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2L|8|@]|9|@]|A|$]]|$1|19|3|1A|5|W|7|2M|8|@]|9|@]|A|$X|Y]]|$1|1B|3|1C|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|W|7|2P|8|@]|9|@]|A|$X|Y]]|$1|1H|3|1I|5|6|7|2Q|8|@$11|2R|12|2S|13|14]|$11|2T|12|2U|13|14]]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1L|3|18|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|W|7|2X|8|@]|9|@]|A|$X|Y]]|$1|1O|3|1P|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|W|7|30|8|@]|9|@]|A|$X|Y]]|$1|1U|3|-4|5|6|7|31|8|@]|9|@]|A|$]]]|1V|$1W|$5|1X|1Y|1Z|A|$20|21]]]]

<h1>Property Removal in JavaScript</h1>

<p>There are many different options presented on this page, not because most of the options are wrong—or because the answers are duplicates—but because the appropriate technique depends on the situation you're in and the goals of the tasks you and/or you team are trying to fulfill. To answer you question unequivocally, one needs to know:</p>

<ol>
<li>The version of ECMAScript you're targeting</li>
<li>The range of object types you want to remove properties on and the type of property names you need to be able to omit (Strings only? Symbols? Weak references mapped from arbitrary objects? These have all been types of property pointers in JavaScript for years now)</li>
<li>The programming ethos/patterns you and your team use. Do you favor functional approaches and mutation is verboten on your team, or do you employ wild west mutative object-oriented techniques?</li>
<li>Are you looking to achieve this in pure JavaScript or are you willing &amp; able to use a 3rd-party library?</li>
</ol>

<p>Once those four queries have been answered, there are essentially four categories of "property removal" in JavaScript to chose from in order to meet your goals. They are:</p>

<h2>Mutative object property deletion, unsafe</h2>

<p>This category is for operating on object literals or object instances when you want to retain/continue to use the original reference and aren't using stateless functional principles in your code. An example piece of syntax in this category:</p>

<pre><code>'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
</code></pre>

<p>This category is the oldest, most straightforward &amp; most widely supported category of property removal. It supports <code>Symbol</code> &amp; array indexes in addition to strings and works in every version of JavaScript except for the very first release. However, it's mutative which violates some programming principles and has performance implications. It also can result in uncaught exceptions when used on <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete" rel="noreferrer">non-configurable properties in strict mode</a>.</p>

<h2>Rest-based string property omission</h2>

<p>This category is for operating on plain object or array instances in newer ECMAScript flavors when a non-mutative approach is desired and you don't need to account for Symbol keys:</p>

<pre><code>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 :(
</code></pre>

<h2>Mutative object property deletion, safe</h2>

<p>This category is for operating on object literals or object instances when you want to retain/continue to use the original reference while guarding against exceptions being thrown on unconfigurable properties:</p>

<pre><code>'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
</code></pre>

<p>In addition, while mutating objects in-place isn't stateless, you can use the functional nature of <code>Reflect.deleteProperty</code> to do partial application and other functional techniques that aren't possible with <code>delete</code> statements.</p>

<h2>Syntax-based string property omission</h2>

<p>This category is for operating on plain object or array instances in newer ECMAScript flavors when a non-mutative approach is desired and you don't need to account for Symbol keys:</p>

<pre><code>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 :(
</code></pre>

<h2>Library-based property omission</h2>

<p>This category is generally allows for greater functional flexibility, including accounting for Symbols &amp; omitting more than one property in one statement:</p>

<pre><code>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"
</code></pre>


blocks|key|3141088|text|@johnstock，我们还可以使用JavaScript的原型概念向对象添加方法，以删除调用对象时可用的任何传递的键。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3141089|上面的答案是值得赞赏的。|3141090|​|3141091|var+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*"
};

//+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+}|code-block|syntax|javascript|3141092|3141093|entityMap^0|0|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|W|8|@]|D|@]|E|$M|N]]|$1|O|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|Q|$]]

<p><strong>@johnstock</strong>, we can also use JavaScript's prototyping concept to add method to objects to delete any passed key available in calling object.</p>
<p>Above answers are appreciated.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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 }</code></pre>
</div>
</div>
</p>


blocks|key|5397271|text|Spread+Syntax+(ES6)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5397272|要完成Koen's+answer，如果您想要使用扩展语法删除动态变量，您可以这样做：|5397273|​|5397274|const+key+=+'a';

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

console.log(foo);++//+1
console.log(rest);+//+{+b:+2,+c:+3+}|code-block|syntax|javascript|5397275|5397276|*+foo将是一个值为a+(即1)的新变量。|style|CODE|5397277|扩展答案|5397278|有几种常见的方法可以从对象中删除属性。|5397279|每种方法都有自己的优缺点(check+this+performance+comparison)：|5397280|5397281|它是可读和简短的，但是，如果你在大量对象上操作，它可能不是最佳选择，因为它的性能没有得到优化。|5397282|delete+obj[key];|5397283|5397284|它比delete快两倍多，但是属性是而不是+deleted，并且可以迭代。|BOLD|5397285|obj[key]+=+null;
obj[key]+=+false;
obj[key]+=+undefined;|5397286|5397287|这个ES6操作符允许我们返回一个全新的对象，不包括任何属性，而不会改变现有的对象。缺点是，它的性能比上面的更差，当你需要一次删除许多属性时，不建议使用它。|5397288|{+[key]:+val,+...rest+}+=+obj;|5397289|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax|1|https://stackoverflow.com/questions/208105/how-do-i-remove-a-property-from-a-javascript-object/40493600#40493600|2|https://jsperf.com/delete-vs-undefined-vs-null/16^0|0|D|0|0|3|D|1|0|0|0|0|2|3|B|1|0|0|0|D|X|2|0|0|0|0|0|2|6|I|3|0|0|0|2|3|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@$A|1Q|B|1R|1|1S]]|C|$]]|$1|D|3|E|5|6|7|1T|8|@]|9|@$A|1U|B|1V|1|1W]]|C|$]]|$1|F|3|G|5|6|7|1X|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1Y|8|@]|9|@]|C|$K|L]]|$1|M|3|G|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|20|8|@$A|21|B|22|P|Q]|$A|23|B|24|P|Q]]|9|@]|C|$]]|$1|R|3|S|5|6|7|25|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|26|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|27|8|@]|9|@$A|28|B|29|1|2A]]|C|$]]|$1|X|3|-4|5|6|7|2B|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|2C|8|@]|9|@]|C|$]]|$1|10|3|11|5|J|7|2D|8|@]|9|@]|C|$K|L]]|$1|12|3|-4|5|6|7|2E|8|@]|9|@]|C|$]]|$1|13|3|14|5|6|7|2F|8|@$A|2G|B|2H|P|Q]|$A|2I|B|2J|P|15]]|9|@]|C|$]]|$1|16|3|17|5|J|7|2K|8|@]|9|@]|C|$K|L]]|$1|18|3|-4|5|6|7|2L|8|@]|9|@]|C|$]]|$1|19|3|1A|5|6|7|2M|8|@$A|2N|B|2O|P|Q]]|9|@]|C|$]]|$1|1B|3|1C|5|J|7|2P|8|@]|9|@]|C|$K|L]]|$1|1D|3|-4|5|6|7|2Q|8|@]|9|@]|C|$]]]|1E|$1F|$5|1G|1H|1I|C|$1J|1K]]|1L|$5|1G|1H|1I|C|$1J|1M]]|1N|$5|1G|1H|1I|C|$1J|1O]]]]

<h3 id="spread-syntax-es6-2iw6"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax" rel="noreferrer">Spread Syntax</a> (ES6)</h3>
<p>To complete <a href="https://stackoverflow.com/questions/208105/how-do-i-remove-a-property-from-a-javascript-object/40493600#40493600">Koen's answer</a>, in case you want to remove a dynamic variable using the spread syntax, you can do it like so:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const key = 'a';

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

console.log(foo);  // 1
console.log(rest); // { b: 2, c: 3 }</code></pre>
</div>
</div>
</p>
<p>* <em><code>foo</code> will be a new variable with the value of <code>a</code> (which is 1).</em></p>
<h3 id="extended-answer-4411">Extended answer </h3>
<p>There are a few common ways to remove a property from an object. <br/>Each one has its own pros and cons (<a href="https://jsperf.com/delete-vs-undefined-vs-null/16" rel="noreferrer">check this performance comparison</a>):</p>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete" rel="noreferrer"><em><strong>Delete Operator</strong></em></a></p>
<p>It is readable and short, however, it might not be the best choice if you are operating on a large number of objects as its performance is not optimized.</p>
<pre><code>delete obj[key];
</code></pre>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators" rel="noreferrer"><em><strong>Reassignment</strong></em></a></p>
<p>It is more than two times faster than <code>delete</code>, however the property is <strong>not</strong> deleted and can be iterated.</p>
<pre><code>obj[key] = null;
obj[key] = false;
obj[key] = undefined;
</code></pre>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax" rel="noreferrer"><em><strong>Spread Operator</strong></em></a></p>
<p>This <code>ES6</code> operator allows us to return a brand new object, excluding any properties, without mutating the existing object. The downside is that it has the worse performance out of the above and is not suggested to be used when you need to remove many properties at a time.</p>
<pre><code>{ [key]: val, ...rest } = obj;
</code></pre>


blocks|key|823286|text|用于克隆没有属性的对象的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|823287|例如：|823288|let+object+=+{+a:+1,+b:+2,+c:+3+};|code-block|syntax|javascript|823289|我们需要删除a。|CODE|823290|具有显式属性密钥的|823291|：|ordered-list-item|823292|823293|const+{+a，...rest+}=+object；object+=+rest;|823294|带有可变属性密钥的|823295|823296|823297|const+propKey+=+'a'；const+{+propKey:+propValue，...rest+}=对象；object+=+rest;|823298|823299|一个很酷的箭头函数：|823300|823301|const+removeProperty+=+(propKey，{+propKey:+propValue，...rest+})+rest；=>+=+removeProperty('a'，object);|823302|适用于的|823303|多个属性|823304|823305|const+removeProperties+=+(object，...keys)+=>+(keys.length？removeProperties(removeProperty(keys.pop()，object)，...keys)：object);|823306|使用|823307|object+=+removeProperties(object,+'a',+'b')+//+result+=>+{+c:+3+}|823308|或|823309|++++const+propsToRemove+=+['a',+'b']
++++object+=+removeProperties(object,+...propsToRemove)+//+result+=>+{+c:+3+}|823310|entityMap^0|C|1|0|0|0|6|1|0|2|6|0|0|0|0|2|6|0|0|0|0|0|5|4|0|0|0|3|1|0|0|4|0|0|0|0|2|0|0|0|1|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1V|8|@$9|1W|A|1X|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|R|3|S|5|T|7|21|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|23|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|Z|3|S|5|T|7|27|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|11|3|12|5|6|7|29|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]|$1|14|3|15|5|T|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|2F|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2G|8|@$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|T|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|2N|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|J|7|2R|8|@]|D|@]|E|$K|L]]|$1|1K|3|1L|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|1M|3|1N|5|J|7|2V|8|@]|D|@]|E|$K|L]]|$1|1O|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]]|1P|$]]

<p><strong>To clone an object without a property:</strong></p>
<p>For example:</p>
<pre><code>let object = { a: 1, b: 2, c: 3 };
</code></pre>
<p>And we need to delete <code>a</code>.</p>
<ol>
<li><p>With an <strong>explicit prop key</strong>:</p>
<pre><code>const { a, ...rest } = object;
object = rest;
</code></pre>
</li>
<li><p>With a <strong>variable prop key</strong>:</p>
<pre><code>const propKey = 'a';
const { [propKey]: propValue, ...rest } = object;
object = rest;
</code></pre>
</li>
<li><p>A cool <strong>arrow function</strong> :</p>
<pre><code> const removeProperty = (propKey, { [propKey]: propValue, ...rest }) =&gt; rest;

 object = removeProperty('a', object);
</code></pre>
</li>
<li><p>For <strong>multiple properties</strong></p>
<pre><code>const removeProperties = (object, ...keys) =&gt; (keys.length ? removeProperties(removeProperty(keys.pop(), object), ...keys) : object);
</code></pre>
</li>
</ol>
<p><em><strong>Usage</strong></em></p>
<pre><code>object = removeProperties(object, 'a', 'b') // result =&gt; { c: 3 }
</code></pre>
<p><em><strong>Or</strong></em></p>
<pre><code>    const propsToRemove = ['a', 'b']
    object = removeProperties(object, ...propsToRemove) // result =&gt; { c: 3 }
</code></pre>


blocks|key|3986472|text|您可以使用如下所示的过滤器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3986473|​|3986474|var+myObject+=+{
++++"ircEvent":+"PRIVMSG",
++++"method":+"newURI",
++++"regex":+"%5Ehttp://.*"
};

//+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)|code-block|syntax|javascript|3986475|3986476|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>You can use a filter like below</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

// Way 1

let filter1 = {}
  Object.keys({...myObject}).filter(d =&gt; {
  if(d !== 'regex'){
    filter1[d] = myObject[d];
  }
})

console.log(filter1)

// Way 2

let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d =&gt;
d[0] !== 'regex'
))

console.log(filter2)</code></pre>
</div>
</div>
</p>


blocks|key|3141375|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3141376|let+myObject+=+{
++++"ircEvent":+"PRIVMSG",
++++"method":+"newURI",
++++"regex":+"%5Ehttp://.*"
};


obj+=+Object.fromEntries(
++++Object.entries(myObject).filter(function+(m){
++++++++return+m[0]+!=+"regex"/*or+whatever+key+to+delete*/
++++}
))

console.log(obj)|code-block|syntax|javascript|3141377|3141378|您还可以使用Object.entries像对待a2d数组一样处理对象，并像在普通数组中那样使用splice删除元素，或者像对待数组一样过滤对象，然后将重新构造的对象分配回原始变量|offset|length|style|CODE|3141379|entityMap^0|0|0|0|6|E|N|3|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|S|8|@$J|T|K|U|L|M]|$J|V|K|W|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|O|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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)</code></pre>
</div>
</div>
</p>
<p>You can also just treat the object like <code>a2d</code> array using <code>Object.entries</code>, and use splice to remove an element as you would in a normal array, or simply filter through the object, as one would an array, and assign the reconstructed object back to the original variable</p>


blocks|key|3986620|text|如果您不想修改原始对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3986621|在不改变对象的情况下删除属性|offset|length|style|BOLD|3986622|如果需要考虑可变性，您可以通过复制旧对象中的所有属性来创建一个全新的对象，但您想要删除的属性除外。|3986623|​|3986624|let+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*"
};

let+prop+=+'regex';
const+updatedObject+=+Object.keys(myObject).reduce((object,+key)+=>+{
++if+(key+!==+prop)+{
++++object[key]+=+myObject[key]
++}
++return+object
},+{})

console.log(updatedObject);|code-block|syntax|javascript|3986625|3986626|entityMap^0|0|0|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|Z|8|@]|9|@]|A|$O|P]]|$1|Q|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

<p>If you don't want to modify the original object.</p>
<p><strong>Remove a property without mutating the object</strong></p>
<p>If mutability is a concern, you can create a completely new object by copying all the properties from the old, except the one you want to remove.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) =&gt; {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})

console.log(updatedObject);</code></pre>
</div>
</div>
</p>


blocks|key|5397774|text|下面是一种ES6方法，可以轻松删除该条目：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5397775|​|5397776|let+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*"
};

const+removeItem+=+'regex';

const+{+[removeItem]:+remove,+...rest+}+=+myObject;

console.log(remove);+//+"%5Ehttp://.*"
console.log(rest);+//+Object+{+ircEvent:+"PRIVMSG",+method:+"newURI"+}|code-block|syntax|javascript|5397777|5397778|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here's an ES6 way to remove the entry easily:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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" }</code></pre>
</div>
</div>
</p>


blocks|key|3141607|text|删除对象的两种方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3141608|3141609|正在使用...在……里面|ordered-list-item|3141610|3141611|函数键(DeleteUser){+const+newUsers+=+{}；for+(用户中的常量uid+){+if+(uid+!==键){+newUsersuid+=+usersuid；}+newUsers+}|3141612|或|3141613|delete+users[key]|code-block|syntax|javascript|3141614|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|T|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|X|8|@]|9|@]|A|$N|O]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

<p>Two ways to delete an object</p>
<ol>
<li><p>using <em>for</em> ... <em>in</em></p>
<pre><code> function deleteUser(key) {

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

     return newUsers
 }
</code></pre>
</li>
</ol>
<p>or</p>
<pre><code>delete users[key]
</code></pre>


blocks|key|5397910|text|让我们保持简单，切中要害：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5397911|只需将特定属性/字段设置为=未定义|offset|length|style|BOLD|5397912|var+myObject+=+{
++++'i':+"How+are+you?",
++++'am':+"Dear",
++++'fine':+"Hello"
};

myObject.am+=+undefined;

console.log(myObject);

>+{i:+"How+are+you?",+am:+undefined,+fine:+"Hello"}|code-block|syntax|javascript|5397913|entityMap^0|0|E|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Let's keep it simple, to the point:</p>
<p>Just set that specific property/field equal to = <strong>undefined</strong></p>
<pre><code>var myObject = {
    'i': &quot;How are you?&quot;,
    'am': &quot;Dear&quot;,
    'fine': &quot;Hello&quot;
};

myObject.am = undefined;

console.log(myObject);

&gt; {i: &quot;How are you?&quot;, am: undefined, fine: &quot;Hello&quot;}
</code></pre>


blocks|key|3141780|text|有几个选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3141781|使用点属性访问器删除|3141782|ordered-list-item|3141783|3141784|​|3141785|const+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*",
};

delete+myObject.regex;
console.log(myObject);|code-block|syntax|javascript|3141786|3141787|3141788|删除使用方括号属性访问器|3141789|3141790|3141791|const+myObject+=+{
++++++"ircEvent":+"PRIVMSG",
++++++"method":+"newURI",
++++++"regex":+"%5Ehttp://.*",
++++};

delete+myObject['regex'];
console.log(myObject);
//+or
const+name+=+'ircEvent';
delete+myObject[name];
console.log(myObject);|3141792|3141793|3141794|替代选项是使用对象解构和rest语法，但以不可变的方式使用原始对象。|3141795|3141796|3141797|+const+myObject+=+{
++++++"ircEvent":+"PRIVMSG",
++++++"method":+"newURI",
++++++"regex":+"%5Ehttp://.*",
++++};

const+{+regex,+...myObjectRest}+=+myObject;
console.log(myObjectRest);+|3141798|3141799|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|-4|5|E|7|18|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1B|8|@]|9|@]|A|$L|M]]|$1|N|3|H|5|6|7|1C|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|P|3|Q|5|E|7|1E|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|H|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|U|5|K|7|1H|8|@]|9|@]|A|$L|M]]|$1|V|3|H|5|6|7|1I|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|X|3|Y|5|E|7|1K|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|H|5|6|7|1M|8|@]|9|@]|A|$]]|$1|11|3|12|5|K|7|1N|8|@]|9|@]|A|$L|M]]|$1|13|3|H|5|6|7|1O|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|15|$]]

<p>There are a couple of options:</p>
<ol>
<li>Remove using a dot property accessor</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*",
};

delete myObject.regex;
console.log(myObject);</code></pre>
</div>
</div>
</p>
<ol start="2">
<li>Remove using square brackets property accessor</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const myObject = {
      "ircEvent": "PRIVMSG",
      "method": "newURI",
      "regex": "^http://.*",
    };

delete myObject['regex'];
console.log(myObject);
// or
const name = 'ircEvent';
delete myObject[name];
console.log(myObject);</code></pre>
</div>
</div>
</p>
<ol start="3">
<li>Alternative option but in an immutable manner without altering the original object, is using object destructuring and rest syntax.</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code> const myObject = {
      "ircEvent": "PRIVMSG",
      "method": "newURI",
      "regex": "^http://.*",
    };

const { regex, ...myObjectRest} = myObject;
console.log(myObjectRest); </code></pre>
</div>
</div>
</p>


blocks|key|5398047|text|我们可以使用以下命令删除|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5398048|使用delete+object.property|5398049|using+delete+object'property'|unordered-list-item|5398050|
|5398051|using+rest，|5398052|ordered-list-item|5398053|删除多个属性|5398054|5398055|​|5398056|let+myObject+=+{
++"ircEvent":+"PRIVMSG",
++"method":+"newURI",
++"regex":+"%5Ehttp://.*",
++"regex1":+"%5Ehttp://.*",
++"regex2":+"%5Ehttp://.*",
++"regex3":+"%5Ehttp://.*",
++"regex4":+"%5Ehttp://.*"
};

delete+myObject.regex;+//+using+delete+object.property

//+Or+

delete+myObject['regex1'];+//+using+delete+object['property']

const+{+regex2,+regex3,+regex4,+...newMyObject+}+=+myObject;

console.log(newMyObject);|code-block|syntax|javascript|5398057|5398058|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|13|8|@]|9|@]|A|$]]|$1|K|3|-4|5|L|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|17|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|18|8|@]|9|@]|A|$U|V]]|$1|W|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|Y|$]]

<p>We can remove using</p>
<ol>
<li>using delete object.property</li>
<li>using delete object['property']</li>
<li>using rest, remove multiple property</li>
</ol>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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);</code></pre>
</div>
</div>
</p>


<p>Say I create an object as follows:</p>
<pre class="lang-js prettyprint-override"><code>let myObject = {
  &quot;ircEvent&quot;: &quot;PRIVMSG&quot;,
  &quot;method&quot;: &quot;newURI&quot;,
  &quot;regex&quot;: &quot;^http://.*&quot;,
};
</code></pre>
<p>How should I remove the property <code>regex</code> to end up with new <code>myObject</code> as follows?</p>
<pre class="lang-js prettyprint-override"><code>let myObject = {
  &quot;ircEvent&quot;: &quot;PRIVMSG&quot;,
  &quot;method&quot;: &quot;newURI&quot;,
};
</code></pre>


Remove properties from objects (JavaScript)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设我创建一个对象，如下所示：let myObject = {  "ircEvent": "PRIVMSG",  "method": "newURI",  "regex": "^http://.*",};我应该如何删除属性regex以获得新的myObject，如下所示？let myObject = {  "ircEve...

问从对象中删除属性(JavaScript)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从对象中删除属性(JavaScript)EN