Delete and delete operators in javascript_javascript skills

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'，因为有DontDelete
  delete arguments; // false;
  typeof arguments; // "object"

  //也不能删除函数的length,因为有DontDelete
  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;

/* 通过变量声明生成全局对象的属性，拥有DontDelete */
var foo = 1;

/* 通过未声明的变量赋值生成全局对象的属性，没有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'创建的同时生成DontDelete */
function foo() {};
/* 之后的赋值过程不改变已有属性的内部属性，DontDelete仍然存在 */
foo = 1;
delete foo; // false;
typeof foo; // "number"
/* 但赋值一个不存在的属性时，创建了一个没有内部属性的属性，因此没有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);

The

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

The

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_;

你可能不知道在什么情况下使用删除运算符。答案是，只要你真的想从对象中删除一个属性。

有的时候，Javascript开发不是删除一个属性，而是把这个属性值设置为null.像下面这样：

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

虽然这有效地切断从原来的值的属性，但该属性本身仍然存在的对象上，你可以看到如下：

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

同时，像in和for in 循环运算将不会报告null属性的存在，如果你使用个对象，可能使用这些方法来检查一个对象，你可能想确保你真正删除任何不需要的属性。

最后，你应该记住，删除并没有破坏属性的值，仅仅属性本身，看下面的例子：

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

这里，name和benjamin.name映射到相同的值，真如你所看到的，删除benjamin.name并不会影响name.

以上，就是我对delete运算符的概述，不妥之处，欢迎大家批评指正。