What are delete and delete operators in js? and usage example analysis

Each property has zero to more internal properties such as *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 variable objects—either activation objects (in function code) or global objects (in global code)— Attributes, these attributes are accompanied by the internal attribute DontDelete. 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

This 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 sub

This is why it cannot 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 deleted*/

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

Build-ins and DontDelete|Build-ins and DontDelete

So this is why all this happens: a special internal property of the property controls whether the property can be delete. 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

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

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: The internal properties are determined when the properties are generated, and subsequent assignment processes will not change the internal properties of existing properties. 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 attributes 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 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 by var are not allowed to be deleted

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

ps: delete operator in Javascript

Delete is the Javascript language One of the less frequently used operations, but sometimes, when we need to perform a delete or clear action, we need a 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.php.cn"
};
delete Benjamin.name;
//Outputs: Object { url: "http://www.php.cn" }
console.log(Benjamin);

The

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

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

However, it can delete "global variables" because they are in fact global objects ( In the browser, it is a property of the window) object.

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

The delete operator also has a return value. If the 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 if in strict mode an error will be thrown.

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.php.cn"
};
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_;

You may not know when to use the delete operator. The answer is, whenever you really want to remove a property from an object.

Sometimes, instead of deleting an attribute, Javascript development sets the attribute value to null. Like the following:

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

Although this works The property is cut off from the original value, but the property itself still exists on the object, as you can see below:

// Outputs: Object { name: null, url: "http://www.php.cn" }
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.

The above is the detailed content of What are delete and delete operators in js? and usage example analysis. For more information, please follow other related articles on the PHP Chinese website!