Javascript中的delete

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

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

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

var x=1;//Global code 
function test(){ 
var y=2;//Function Code 
eval("var z=3");//Eval Code in Function 
} 
eval("function evalTest(){}");//Eval Code in Global 

/* remember that `this` refers to global object when in global scope */ 
var GLOBAL_OBJECT = this; 

var foo = 1; 
GLOBAL_OBJECT.foo; // 1 
foo === GLOBAL_OBJECT.foo; // true 

function bar(){} 
typeof GLOBAL_OBJECT.bar; // "function" 
GLOBAL_OBJECT.bar === bar; // true 

(function(foo){ 

var bar = 2; 
function baz(){} 

/* 
In abstract terms, 

Special `arguments` object becomes a property of containing function`s Activation object: 
ACTIVATION_OBJECT.arguments; // Arguments object 

...as well as argument `foo`: 
ACTIVATION_OBJECT.foo; // 1 

...as well as variable `bar`: 
ACTIVATION_OBJECT.bar; // 2 

...as well as function declared locally: 
typeof ACTIVATION_OBJECT.baz; // "function" 
*/ 

})(1); 

var GLOBAL_OBJECT = this; 

/* `foo` is created as a property of calling context Variable object, 
which in this case is a Global object */ 

eval(`var foo = 1;`); 
GLOBAL_OBJECT.foo; // 1 

(function(){ 

/* `bar` is created as a property of calling context Variable object, 
which in this case is an Activation object of containing function */ 

eval(`var bar = 1;`); 

/* 
In abstract terms, 
ACTIVATION_OBJECT.bar; // 1 
*/ 

})(); 

var GLOBAL_OBJECT = this; 

/* `foo` is a property of a Global object. 
It is created via variable declaration and so has DontDelete attribute. 
This is why it can not be deleted. */ 

var foo = 1; 
delete foo; // false 
typeof foo; // "number" 

/* `bar` is a property of a Global object. 
It is created via function declaration and so has DontDelete attribute. 
This is why it can not be deleted either. */ 

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

/* `baz` is also a property of a Global object. 
However, it is created via property assignment and so has no DontDelete attribute. 
This is why it can be deleted. */ 

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

(function(foo, bar){ 

delete foo; // false 
foo; // 1 

delete bar; // false 
bar; // `blah` 

})(1, `blah`); 

var GLOBAL_OBJECT = this; 

/* create global property via variable declaration; property has DontDelete */ 
var foo = 1; 

/* create global property via undeclared assignment; property has no DontDelete */ 
bar = 2;//可理解為 window.bar=2; 根據上面的第五點是可以刪除的 

delete foo; // false 
typeof foo; // "number" 

delete bar; // true 
typeof bar; // "undefined" 

/* `foo` is created as a property with DontDelete */ 
function foo(){} 

/* Later assignments do not modify attributes. DontDelete is still there! */ 
foo = 1; 
delete foo; // false 
typeof foo; // "number" 

/* But assigning to a property that doesn`t exist, 
creates that property with empty attributes (and so without DontDelete) */ 

this.bar = 1; 
delete bar; // true 
typeof bar; // "undefined" 

eval("var x = 1;"); 
console.log(x); // 1 
delete x; 
console.log(typeof x); // undefined 

eval("function test(){ var x=1; console.log(delete x);/* false */;return 1;}"); 
console.log(test()); // 1 
delete test; 
console.log(typeof test); // undefined　

var x=1; 
delete x; 
console.log(typeof x);//undefined 

function y(){ 
var z=1; 
console.log(delete z);//false 
} 
y(); 
delete y; 
console.log(typeof y);//undefined 

class Object { 
public: 
Object *x; 
} 

Object o; 
o.x = new Object(); 
delete o.x; // 上一行new的Object物件將被釋放 

function C() { this.x = 42; } 
C.prototype.x = 12; 
C.prototype.y = 13; 

var o = new C(); 
o.x; // 42, 建構函式中定義的o.x 

delete o.x; //true 刪除的是自身定義的x 
o.x; // 12, prototype中定義的o.x，即使再次執行delete o.x也不會被刪除 

delete o.y; //true，因為 o自身沒有o.y屬性，y存在於prototype鏈中，也就是說物件自身屬性和prototype屬性是不同的 
o.y; //13