javascript系列之this

1 activeExecutionContext={
2    VO:{...},
3this:thisValue
4 }

1//全局对象的显式属性定义2this.a=10;//global.a=103 alert(a);//104//通过对无类型标识符赋值的隐式定义5 b=20;
6 alert(this.a);//207//通过变量声明隐式定义，因为全局上下文的变量对象就是全局对象自身8var c=30;
9 alert(this.c);//30

 1var foo={x:10};
 2var bar={
 3     x:20,
 4     test:function(){
 5         alert(this===bar);//true 6         alert(this.x);//20 7this=foo;//error,不能改变this值 8         alert(this.x);//如果这里没有错的话，结果会是10，不是20 9    }
10}；
11//当进入上下文时，this值由"bar"对象决定的。为什么这样-将在下面详细讨论12 bar.test();//true,2013 foo.test=bar.test;
14//然而，此时在这里的this将指向"foo"-即使我们调用同一个函数15 foo.test()；//false,10

1function foo(){
2     alert(this);
3}
4 foo();//global5 alert(foo===foo.prototype.constructor);//true6//但是对于同一函数的另一种调用表达式形式，this值是不同的7 foo.prototype.constructor();//foo.prototype

 1var foo={
 2     bar:function(){
 3         alert(this);
 4         alert(this===foo);
 5    }
 6};
 7 foo.bar();//foo,true 8var exampleFunc=foo.bar;
 9 alert(exampleFunc===foo.bar);//true10//同一函数的另一种调用表达式形式，得到不同的this值11 exampleFunc();//global,false

1var valueOfReferenceType={
2     base:<base object>,
3     propertyName:<property name>
4 }

1    var foo = 10;
2    function bar() {}

1var fooReference={
2    base;global,
3     propertyName:‘foo‘
4};
5var barReference={
6    base:global,
7     propertyName:‘bar‘
8 };

1    function GetValue(value) {
3      if (Type(value) != Reference) {
4        return value;
5      }     
7      var base = GetBase(value); 
9      if (base === null) {
10        thrownew ReferenceError;
11      } 
13      return base.[[Get]](GetPropertyName(value));
15    }

1    GetValue(fooReference); // 10
2    GetValue(barReference); // function object "bar"

1    foo.bar();
2    foo[‘bar‘]();

1    var fooBarReference = {
2      base: foo,
3      propertyName: ‘bar‘
4    };  
6    GetValue(fooBarReference); // function object "bar"

在函数上下文中的this值由调用者提供并由当前的调用表达式形式所决定(这个函数在语法意义上如何书写的)。
如果在调用(...)的左边，有一个Reference类型的值，这样this值被这设置为Reference类型的base对象。
在其他所有的情形(例如与Reference类型不同的任何类型值)，this值一直设置为null。但由于this值为null没
有任何意义，它会隐式的转化为全局对象

1function foo() {
2returnthis;
3}5 foo(); // global

1var fooReference = {
2  base: global,
3   propertyName: ‘foo‘
4 };

1var foo = {
2   bar: function () {
3returnthis;
4  }
5};
67 foo.bar(); // foo

1var fooBarReference = {
2  base: foo,
3   propertyName: ‘bar‘
4 };

1var test = foo.bar;
2 test(); // global

1var testReference = {
2  base: global,
3   propertyName: ‘test‘
4 }

 1function foo() {
 2   alert(this);
 3} 5 foo(); // global, because 7var fooReference = {
 8  base: global,
 9   propertyName: ‘foo‘
10};12 alert(foo === foo.prototype.constructor); // true14// another form of the call expression16 foo.prototype.constructor(); // foo.prototype, because18var fooPrototypeConstructorReference = {
19  base: foo.prototype,
20   propertyName: ‘constructor‘
21 };

 1function foo() {
 2   alert(this.bar);
 3}
 4 5var x = {bar: 10};
 6var y = {bar: 20};
 7 8 x.test = foo;
 9 y.test = foo;
1011 x.test(); // 1012 y.test(); // 20

1 (function  () {
2   alert(this); // null => global3 })();

 1var foo = {
 2   bar: function () {
 3     alert(this);
 4  }
 5};
 6 7 foo.bar(); // Reference, OK => foo 8 (foo.bar)(); // Reference, OK => foo 910 (foo.bar = foo.bar)(); // global?11 (false || foo.bar)(); // global?12 (foo.bar, foo.bar)(); // global?

1function foo() {
2function bar() {
3     alert(this); // global4  }
5   bar(); // the same as AO.bar()6 }

 1var x = 10;
 2 3with ({
 4 5   foo: function () {
 6     alert(this.x);
 7  },
 8   x: 20
 910}) {
1112   foo(); // 201314}
1516// because1718var  fooReference = {
19  base: __withObject,
20   propertyName: ‘foo‘
21 };

 1try {
 2throwfunction () {
 3     alert(this);
 4  };
 5 } catch (e) {
 6   e(); // __catchObject - in ES3, global - fixed in ES5 7}
 8 9// on idea1011var eReference = {
12  base: __catchObject,
13   propertyName: ‘e‘
14};
1516// but, as this is a bug17// then this value is forced to global18// null => global1920var eReference = {
21  base: global,
22   propertyName: ‘e‘
23 };

1 (function  foo(bar) {
23   alert(this);
45   !bar && foo(1); // "should" be special object, but always (correct) global67 })(); // global

1 function A() {
2   alert(this); // newly created object, below - "a" object
3   this.x = 10;
4 }
5   
6 var a = new A();
7 alert(a.x); // 10

 1var b = 10; 3function a(c) {
 4   alert(this.b);
 5  alert(c);
 6} 8 a(20); // this === global, this.b == 10, c == 2010 a.call({b: 20}, 30); // this === {b: 20}, this.b == 20, c == 3011 a.apply({b: 30}, [40]) // this === {b: 30}, this.b == 30, c == 40