Javascript variables and delete Operators

I just saw a good article, which thoroughly analyzed the delete operator in Javascript. Here is a brief introduction.
 
Although it is a small delete operator, its behavior is extremely complicated.
 
Javascript Variables
Objects deleted by the delete Operator
Executing delete on variables
Attributes that can be deleted and attributes that cannot be deleted
Variables that can be deleted and variables that cannot be deleted
Return Value of delete
Javascript Variables
In Javascript, the variable = Object Property is because Javascript creates a Global object before executing the script, and all Global variables are attributes of this Global object, when the function is executed, an Activation object is created. All local variables are attributes of this Activation object. For example:
 
Var global = 42;
This. global; // 42. You can use this to access Global objects.
 
This. global2 = 12;
Global2; // 12
 
Function foo (){
Var local = 36;
// However, you cannot directly access Activation,
// Therefore, the local variable cannot be accessed through foo. local.
}
Objects deleted by the delete Operator
C ++ also has the delete operator, which deletes the object pointed to by the pointer. For example:
 
// C ++
Class Object {
Public:
Object * x;
}
 
Object o;
O. x = new Object ();
Delete o. x; // The new Object in the previous row will be released.
However, unlike C ++, Javascript delete does not delete the objects pointed to by o. x, but deletes the o. x attribute itself.
 
// Javascript
Var o = {};
O. x = new Object ();
Delete o. x; // The new Object in the previous Row still exists.
O. x; // undefined. The attribute named x of o is deleted.
In actual Javascript, delete o. after x, the Object will be reclaimed due to the loss of reference, So delete o. x is equivalent to deleting o. x points to the Object, but this action is not the ECMAScript standard. That is to say, even if an implementation does not delete the Object at all, it is not in violation of the ECMAScript standard.
 
You can use the following code to confirm "delete attributes rather than objects.
 
Var o = {};
Var a = {x: 10 };
O. a =;
Delete o. a; // The o. a attribute is deleted.
O. a; // undefined
A. x; // 10, because the {x: 10} object is still referenced by a, it will not be recycled.
In addition, delete o. x can also write delete o ["x"], with the same effect.
 
Executing delete on variables
Because the variable is also a Global or Activation object attribute, the delete operation on the variable is the same result.
 
Var global = 42;
Delete global; // delete Global. global
 
Function foo (){
Var local = 36;
Delete local; // delete Activation. local
}
Attributes that can be deleted and attributes that cannot be deleted
Not all attributes can be deleted. For example, the attribute declared in prototype cannot be deleted:
 
Function C () {this. x = 42 ;}
C. prototype. x = 12;
 
Var o = new C ();
O. x; // 42, the o. x defined in the constructor
 
Delete o. x;
O. x; // 12. o. x defined in prototype will not be deleted even if delete o. x is executed again.
The predefined attributes of an object cannot be deleted. This type of attribute is considered to have the DontDelete feature.
 
Var re =/abc/I;
Delete re. ignoreCase;
Re. ignoreCase; // true, ignoreCase cannot be deleted
Variables that can be deleted and variables that cannot be deleted
Variables declared through var and functions declared through function have the DontDelete feature and cannot be deleted.
 
Var x = 36;
Delete x;
X; // 36, x not deleted
 
Y = 12;
Delete y;
Y; // undefined
 
Function foo () {return 42 ;}
Delete foo;
Foo (); // 42
One exception is that the variables declared through var in the Code executed through eval belong to the Global object, but they do not have the DontDelete feature and can be deleted.
 
Eval ("var x = 36 ;");
X; // 42
Delete x;
X; // undefined
But this is also an exception. The variables defined by var in the eval Code have DontDelete and cannot be deleted.
 
Eval ("(function () {var x = 42; delete x; return x ;})();");
// Return 42
Return Value of delete
Delete is a common operator and returns true or false. The rule is: if the property of the object to be deleted exists and has DontDelete, false is returned; otherwise, true is returned. One feature here is that true is returned if the object property does not exist, so the return value is not exactly the same as whether the deletion is successful or not.
 
Function C () {this. x = 42 ;}
C. prototype. y = 12;
Var o = new C ();
 
Delete o. x; // true
O. x; // undefined
"X" in o; // false
// If o. x exists and no DontDelete exists, true is returned.
 
Delete o. y; // true
O. y; // 12
// O itself does not have the o. y attribute, so true is returned.
// You can also see the existence of the prototype chain from here. The attributes of the object and prototype are different.
 
Delete o; // false
// Global. o has the DontDelete feature, so false is returned.
 
Delete undefinedProperty; // true
// Global does not have an attribute named undefinedProperty. Therefore, true is returned.
 
Delete 42; // true
// 42 is not an attribute, so true is returned. Some implementations throw an exception (in violation of the ECMAScript Standard)
 
Var x = 24;
Delete x ++; // true
X; // 25
// The deleted value is the return value of x ++ (24), which is not an attribute. Therefore, true is returned.