So, why can we delete the attributes of an object:

var x = { a: 1 };
delete x.a; // true
x.a; // undefined

But you cannot delete a variable:

var x = 1;
delete x; // false;
x; // 1

You cannot delete a function either:

function x() {};
delete x; // false;
typeof x; // "function"

Note: delete only returns false if a property cannot be deleted.

Each attribute has zero to more internal attributes - *ReadOnly, DontEnum, DontDelete and Internal**. You can think of them as tags - a property may or may not have a special internal property. For today's discussion, we're interested in DontDelete.

When variables and functions are declared, they become properties of the Variable object—either the activation object (in function code) or the global object (in global code). These properties are accompanied by The internal property DontDelete is generated. However, any explicitly/implicitly assigned properties do not generate a DontDelete. And this is essentially why we can delete some properties but not others.

var GLOBAL_OBJECT = this;

/* 'foo' is a property of the global object, which is generated through variable declaration, so it has the internal property DontDelete

That’s why it can’t be deleted*/

var foo = 1;
delete foo; // false
typeof foo; // "number"
/* 'bar

' is a property of the global object, which is generated through variable declaration, so it has the DontDelete child

That’s why it can’t be deleted either*/

function bar() {};
delete bar; // false
typeof bar; // "function"

/* 'baz' is also a property of the global object,

However, it is generated via property assignment, so there is no DontDelete

That’s why it can be removed*/

GLOBAL_OBJECT.baz = "baz";
delete GLOBAL_OBJECT.baz; // true
typeof GLOBAL_OBJECT.baz; // "undefined"

1.5, built-ins and DontDelete | Build-ins and DontDelete

So this is why all this happens: a special internal property of a property controls whether or not the property can be deleted. Note: Some properties of built-in objects have the internal property DontDelete and therefore cannot be deleted; special arguments variables (as we know, properties of activated objects) have DontDelete; the length (return parameter length) property of any function instance also Has DontDelete:

(function() {
  //不能刪除'arguments'，因?yàn)橛蠨ontDelete
  delete arguments; // false;
  typeof arguments; // "object"

  //也不能刪除函數(shù)的length,因?yàn)橛蠨ontDelete
  function f() {};
  delete f.length; // false;
  typeof f.length; // "number"
}) ();

The properties associated with function arguments also have DontDelete and cannot be deleted either

(function(foo,bar) {
  delete foo; // false
  foo; // 1

  delete bar; // false
  bar; // "bah"
}) (1,"bah");

1.6. Undeclared variable assignments | Undeclared assignments

You may remember that an undeclared variable assignment becomes a property of the global object unless the property is found elsewhere in the scope chain. And now we understand the difference between property assignment and variable declaration - the latter generates DontDelete and the former does not - which is why undeclared variable assignments can be deleted.

var GLOBAL_OBJECT = this;

/* 通過變量聲明生成全局對(duì)象的屬性，擁有DontDelete */
var foo = 1;

/* 通過未聲明的變量賦值生成全局對(duì)象的屬性，沒有DontDelete */
bar = 2;
delete foo; // false
delete bar; // true

Note: Internal attributes are determined when the attributes are generated, and subsequent assignment processes will not change the internal attributes of existing attributes. It's important to understand this distinction.

/* 'foo'創(chuàng)建的同時(shí)生成DontDelete */
function foo() {};
/* 之后的賦值過程不改變已有屬性的內(nèi)部屬性，DontDelete仍然存在 */
foo = 1;
delete foo; // false;
typeof foo; // "number"
/* 但賦值一個(gè)不存在的屬性時(shí)，創(chuàng)建了一個(gè)沒有內(nèi)部屬性的屬性，因此沒有DontDelete */
this.bar = 1;
delete bar; // true;
typeof bar; // "undefined"

Summary:

Variable and function declarations are properties of the Activation global object.

Properties have internal properties, one of which - DontDelete - is responsible for determining whether a property can be deleted.

Variables and function declarations in global code or function code all generate attributes with DontDelete.

Function parameters are also attributes of the activation object and also have DontDelete.

Delete attributes in the object: delete object.member

You can only delete your own members

Only global variables declared with var cannot be deleted

Global members added using window. or window[""] can be deleted

ps: delete operator in Javascript

Delete is one of the less frequently used operations in the Javascript language, but sometimes, when we need to perform delete or clear actions, we need the delete operation. In this article, we’ll dive into how to use it and how it works.

The purpose of deletion, as you think, is to delete something. More specifically, it will delete the attributes of the object, as in the following example:

var Benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.com"
};
delete Benjamin.name;
//Outputs: Object { url: "http://www.zuojj.com" }
console.log(Benjamin);

delete operator will not delete ordinary variables, as in the following example:

var benjamin = "http://www.zuojj.com";
delete benjamin;
//Outputs: "http://www.zuojj.com"
console.log(benjamin);

However, it can remove "global variables" because they are in fact properties of the global object (window in browsers) object.

// Because var isn't used, this is a property of window
benjamin = "zuojj";
delete window.benjamin;
// ReferenceError: benjamin is not defined
console.log(benjamin);

delete operator also has a return value. If deletion of an attribute is successful, it returns true. If the attribute cannot be deleted because the attribute is not writable, it will return false, or it will throw an error if in strict mode.

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.com"
};
var nameDeleted = delete benjamin.name;
// Outputs: true
console.log(nameDeleted);
"use strict";
var benjamin_ = "zuojj";
//Outputs: Uncaught SyntaxError: Delete of an unqualified identifier in strict mode.
delete benjamin_;

你可能不知道在什么情況下使用刪除運(yùn)算符。答案是，只要你真的想從對(duì)象中刪除一個(gè)屬性。

有的時(shí)候，Javascript開發(fā)不是刪除一個(gè)屬性，而是把這個(gè)屬性值設(shè)置為null.像下面這樣：

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.com"
};
benjamin.name = null;

雖然這有效地切斷從原來的值的屬性，但該屬性本身仍然存在的對(duì)象上，你可以看到如下：

// Outputs: Object { name: null, url: "http://www.zuojj.com" }
console.log(benjamin);

同時(shí)，像in和for in 循環(huán)運(yùn)算將不會(huì)報(bào)告null屬性的存在，如果你使用個(gè)對(duì)象，可能使用這些方法來檢查一個(gè)對(duì)象，你可能想確保你真正刪除任何不需要的屬性。

最后，你應(yīng)該記住，刪除并沒有破壞屬性的值，僅僅屬性本身，看下面的例子：

var name   = "zuojj",
    benjamin = {};
benjamin.name = name;
delete benjamin.name;
//Outputs: "zuojj"
console.log(name);

這里，name和benjamin.name映射到相同的值，真如你所看到的，刪除benjamin.name并不會(huì)影響name.

以上，就是我對(duì)delete運(yùn)算符的概述，不妥之處，歡迎大家批評(píng)指正。