JavaScript delete用法，属性，特性，执行上下文，激活对象 综合篇

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

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

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

var x=;//Global code
function test(){
var y=;//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 = ;
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 = ;
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"
*/ })();

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 = ;
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(){ /* can't delete `arguments`, since it has DontDelete */ delete arguments; // false
typeof arguments; // "object" /* can't delete function's `length`; it also has DontDelete */ function f(){}
delete f.length; // false
typeof f.length; // "number" })();

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

var GLOBAL_OBJECT = this; /* create global property via variable declaration; property has DontDelete */
var foo = ; /* create global property via undeclared assignment; property has no DontDelete */
bar = ;//可理解为 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 = ;
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 = ;
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=;
delete x;
console.log(typeof x);//undefined function y(){
var z=;
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对象将被释放

var o = {};
o.x = new Object();
delete o.x; // 上一行new的Object对象依然存在
o.x; // undefined，o的名为x的属性被删除了

var o = {};
var a = { x: };
o.a = a;
delete o.a; // o.a属性被删除
o.a; // undefined
a.x; // 10, 因为{ x: 10 } 对象依然被 a 引用，所以不会被回收

function C() { this.x = ; }
C.prototype.x = ;
C.prototype.y = ; 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