摘要：再來(lái)看書(shū)中的例子變量引用了構(gòu)造函數(shù)新生成的變量，所以相當(dāng)于與。而全局變量是全局對(duì)象的屬性。延伸知識(shí)點(diǎn)最近學(xué)，發(fā)現(xiàn)這幾個(gè)知識(shí)點(diǎn)最好形成思維導(dǎo)圖來(lái)理解作用域變量聲明提升全局對(duì)象全局變量引用上下文構(gòu)造函數(shù)原型鏈與原型。

        alert(window.eval===eval);                // true
        alert(window.Object===Object);            // true
        alert(window.Math===Math);                // true
        alert(window.document===document);        // true
        // 我們一開(kāi)始就使用那些函數(shù)方法，屬性都是window對(duì)象的屬性嗎？

瀏覽器對(duì)象模型BOM (Browser Object Model) 使 JavaScript 有能力與瀏覽器“對(duì)話(huà)”。

還有一個(gè)DOM（文檔對(duì)象模型，這是對(duì)HTML進(jìn)行操作的根本）這里略過(guò)。

        // 預(yù)定義的全局變量、函數(shù)（方法）都是window對(duì)象的屬性
        alert(typeof window.Number)            // function
        alert(typeof window.Math)            // object
        alert(typeof window.Math.random)    // function
        // 更改全局變量
        NaN = 11;
        eval = 22;
        Object = 33;
        Math = 44;
        console.log(window.Math);            // 44
        console.log(typeof window.Math)        // number     全局對(duì)象被改寫(xiě)
        
        alert(NaN);     // NaN
        alert(eval);    // 22
        alert(Object);  // 33
        alert(Math);    // 44
        // 這里可能有一個(gè)誤區(qū)：全局對(duì)象不是window嗎？
        // 實(shí)際上：window也是另外一個(gè)全局對(duì)象，但是前提是運(yùn)行在瀏覽器端
        // window全局對(duì)象提供了與當(dāng)前窗口、頁(yè)面有關(guān)的諸多屬性與方法。
        // 除了這些與瀏覽器有關(guān)的全局屬性和方法，window對(duì)象還封裝了JS全局對(duì)象，并向外暴露JS全局對(duì)象的屬性與接口
        

        var a = 1;
        alert(this.a);    // 1
        alert(this);      // "[object Window]"

這里定義了一個(gè)全局變量a，之后調(diào)用this.a和this。結(jié)果大家看到了。全局變量a的作用域是整個(gè)全局對(duì)象內(nèi)可見(jiàn)，或者說(shuō)變量a是全局對(duì)象的屬性。不信？看下面：

        var woshiSB = 1;
        console.log(this);
        var write = "";
        for (var i in this) {
            write += i+"
"
        }
        document.write(write);

看到了下面那個(gè)了？沒(méi)錯(cuò)，還記得for-in語(yǔ)句干啥的嘛？遍歷一個(gè)對(duì)象里的可枚舉屬性（圖中只截取了部分全局對(duì)象（變量）），之后我們發(fā)現(xiàn)了了它woshiSB,這可以說(shuō)在外部環(huán)境、全局上下文環(huán)境中的全局變量是全局對(duì)象的屬性。反過(guò)來(lái)，我們也可以通過(guò)在全局對(duì)象里創(chuàng)建一個(gè)全局變量。且，如果能確定上下文（在任何函數(shù)體外部），滿(mǎn)足這個(gè)前提條件，這個(gè)this指的就是全局對(duì)象了。且，我們可以：

        console.log(this.document === document); // true
        console.log(this.Number===Number);       // true
        // 在瀏覽器中，全局對(duì)象為 window 對(duì)象：
        console.log(this === window);     // true
        
        this.a = 37;                      // 此時(shí)this引用指向全局對(duì)象，所以a是全局對(duì)象的屬性
        console.log(window.a);            // 37
        
        window.b = 38;                    // 同樣的,全局對(duì)象window下的屬性是全局變量
        console.log(this.b);              // 38
        
        this.x = 1;
        alert(this.x===window.x)          // true

全局上下文（引用自MDN）
在全局運(yùn)行上下文中（在任何函數(shù)體外部），this指代全局對(duì)象，無(wú)論是否在嚴(yán)格模式下。

console.log(this.document === document); // true

// 在瀏覽器中，全局對(duì)象為 window 對(duì)象：
console.log(this === window); // true

this.a = 37;
console.log(window.a); // 37

        function f1(){
          return this;
        }
        
        f1() === window; // true

不是在嚴(yán)格模式下執(zhí)行，this的值不會(huì)在函數(shù)執(zhí)行時(shí)被設(shè)置，此時(shí)的this的值會(huì)默認(rèn)設(shè)置為全局對(duì)象。
這里提醒一下：嚴(yán)格的說(shuō)，this全稱(chēng)叫this引用。注意引用二字。

        function f2(){
          "use strict"; // 這里是嚴(yán)格模式
          return this;
        }
        
        f2() === undefined; // true

在嚴(yán)格模式下，如果this未被執(zhí)行的上下文環(huán)境定義，那么它將會(huì)默認(rèn)為undefined。
所謂上下文，加幾個(gè)字理解，想到語(yǔ)文里的“聯(lián)系上下文”了嗎？對(duì)，this引用所處的環(huán)境，或者說(shuō)它位于的作用域。

函數(shù)上下文
在函數(shù)內(nèi)部，this的值取決于函數(shù)是如何調(diào)用的。

包括引用的文章也提到：

如果這個(gè)this屬于某個(gè)function，那么this指代的就是調(diào)用該function的對(duì)象。若這種情況下function只是一個(gè)普通的函數(shù)，而不是某個(gè)類(lèi)的方法，那么this的指代存在兩種可能：
1.在ECMAScript 3標(biāo)準(zhǔn)，以及ECMAScript 5標(biāo)準(zhǔn)的非嚴(yán)格模式下，this指代全局對(duì)象。
2.在ECMAScript 5標(biāo)準(zhǔn)的嚴(yán)格模式下，this指代undefined。

函數(shù)上下文 —— 對(duì)象方法中的this：

        var obj = {
            x:"x",
            fn:function () {
                return this.x;
            }
        };
        console.log(obj.fn())

此時(shí)，obj.fn()中的this引用將會(huì)指向obj這個(gè)全局對(duì)象，也就是obj.x

        var obj = {x:"x"};
        function test(obj) {
            return this.x;
        };
        obj.fn = test;
        alert(obj.fn());

在何處或者如何定義調(diào)用函數(shù)完全不會(huì)影響到this的行為。我們?cè)诙xobj的時(shí)候定義了一個(gè)obj.fn()方法。但是，我們也可以首先定義函數(shù)然后再將其附屬到o.f。這樣做this的行為也一致。

來(lái)看另一個(gè)例子：

        var f = function (x) {
            this.y = x+1;
        };
        var a = {y:10,op:f};
        var b= {y:20,increment:f};
        
        a.op(100);                 // 通過(guò)a來(lái)調(diào)用f，this引用指向a引用的對(duì)象
        alert(a.y);                // 101
        b.increment(43);           // 通過(guò)b來(lái)調(diào)用，this引用指向b引用的對(duì)象
        alert(b.y);                // 44

f引用的匿名函數(shù)里的this引用指向調(diào)用它的對(duì)象。

函數(shù)上下文 —— 構(gòu)造函數(shù)中的this:

我們來(lái)看CDN的例子（改寫(xiě)過(guò)）：

        function c(){
          this.a = 37;
        };
        c.prototype.test = "test";
        
        var o = new c();
        o.sb = "Sb";                                             // o也是對(duì)象
        console.log(o.a);                                        // logs 37
        console.log(o.__proto__===c.prototype);                  // true
        console.log(o.sb);                                       // "Sb"
        Object.prototype.op = "op";
        console.log(c.prototype.__proto__===Object.prototype)    // true
        console.log(Object.prototype.__proto__);                 // null
        console.log(Object.prototype.constructor===Object);      // true

看到這的的默認(rèn)你已經(jīng)懂了構(gòu)造函數(shù)大部分哈。（我們先讀一遍，對(duì)，首先要看懂。）

聲明一個(gè)c函數(shù)，同時(shí)內(nèi)建一個(gè)this引用，當(dāng)然我們并不知道這個(gè)引用指向誰(shuí)。將c函數(shù)作為構(gòu)造函數(shù)調(diào)用，（此時(shí)：構(gòu)造函數(shù)會(huì)隱式生成一個(gè)對(duì)象，對(duì)象內(nèi)建的隱式鏈接指向構(gòu)造函數(shù)的prototype對(duì)象），這個(gè)新對(duì)象的引用賦值給全局變量o，注意是引用賦值，這個(gè)變量同時(shí)也是對(duì)象，Sb那里也看到了?，F(xiàn)在你腦子里是不是生成了一副引用指向圖了呢？把它畫(huà)出來(lái)你就都知道了。

變量o引用了新對(duì)象，則構(gòu)造函數(shù)里的this引用就是指向o，這里展現(xiàn)的是原型鏈，關(guān)于原型鏈我還不夠了解后續(xù)會(huì)繼續(xù)學(xué)習(xí)；
再來(lái)看另一個(gè)：

        function c2(){
          this.a = 37;
          return {a:38};
        };

        o = new c2();
        console.log(o.a); // logs 38    

在最后的例子中（C2），因?yàn)樵谡{(diào)用構(gòu)造函數(shù)的過(guò)程中，手動(dòng)的設(shè)置了返回對(duì)象，與this綁定的默認(rèn)對(duì)象被取消（本質(zhì)上這使得語(yǔ)句this.a = 37成了“僵尸”代碼，實(shí)際上并不是真正的“僵尸”，這條語(yǔ)句執(zhí)行了但是對(duì)于外部沒(méi)有任何影響，因此完全可以忽略它）?！?引自CDN
其實(shí)我對(duì)CDN的解釋也不太懂，可以認(rèn)為，重新改變o引用的對(duì)象，則也改變了this引用的對(duì)象。則this.a肯定指向新對(duì)象。

再來(lái)看書(shū)中的例子：

        var Point = function (x,y) {
            this.x = x;
            this.y = y;
        };
        var p = new Point(4,-5);
        var q = Point(3,8);
        
        console.log(typeof q);    // "undefined"

p變量引用了構(gòu)造函數(shù)新生成的變量，this.x、this.y所以相當(dāng)于p.x與p.y。調(diào)用構(gòu)造函數(shù)，傳參后，就賦值等等。
而變量q，注意這里只是將Point當(dāng)做普通函數(shù)調(diào)用而已，執(zhí)行函數(shù)主體后，也沒(méi)有返回值。So，q的值類(lèi)型是undefined。

再來(lái)看另一個(gè)例子：

        var obj = {
            x:3,
            doit:function () {
                console.log("method is called."+this.x);
            }
        };
        // 1
        var fn = obj.doit;            // 將obj.doit引用的Function對(duì)象賦值給全劇變量    
        fn();                         // "method is called.undefined"
        // 2
        var x = 5;
        fn();                         // "method is called.5"
        // 3
        var obj2 = {x:4,doit2:fn};
        obj2.doit2();                 // "method is called.4"  
        

全局變量obj引用對(duì)象，內(nèi)含obj.x和一個(gè)方法，方法內(nèi)存在this引用。

第二次調(diào)用//2：就是反證第一次的，說(shuō)明this引用的確引用了全局對(duì)象，或者我們看這個(gè)：

        var test = {
            z:"test-z",
            fn:function () {
                console.log(this.z)
            }
        };
        window.fun = test.fn;            // 全局對(duì)象的fun方法
        var z = "var z";                 // 全局變量z
        window.fun();                    // result："var z"    this引用指向全局對(duì)象
        
        var z1 = "var z1";               // 全局變量z1
        test.z1 = "test.z1";             // 屬性z1
        test.fn2 = function () {console.log(this.z1)}    
        test.fn2();                      // result："test.z1"        this引用指向test對(duì)象

所以當(dāng)?shù)谌握{(diào)用時(shí)，doit2引用的Funcion對(duì)象內(nèi)部的this引用指向的是obj2對(duì)象。相當(dāng)于obj2.x

嵌套一個(gè)來(lái)試試：

        var x = "var x";
        var fn = function () {alert(this.x)};
        var obj = {
            x:"obj.x",
            fn:function () {alert(this.x)},
            obj2:{
                x:"obj2.x",
                fn2:function () {alert(this.x)}
            }
        };
        
        // 直接調(diào)用
        obj.obj2.fn2();        // obj2.x
        obj.fn();              // obj.x
        fn();                  // var z

類(lèi)似的，this 的綁定只受最靠近的成員引用的影響

再來(lái)看一個(gè)變形：

        var obj = {
            x:"obj.x",
            doit:function () {
                console.log("doit is called."+this.x);            // 這里的this.x：obj.x
                this.test.doit2();                                
                // 這里的this.x："test.x"
                //  "true"
            },
            test:{
                x:"test.x",
                doit2:function () {
                    var x = "doit2-x";
                    console.log("doit2 is called."+this.x+" | "+this);
                    // 這里的this.x："test.x"
                    console.log(this===window.obj.test && this===obj.test);
                    // "true"    this引用指向嵌套對(duì)象：test
                }
            }
        };
        obj.doit();                    // this.x: "obj.x"
        var x = "var z";             
        window.obj.test.doit2();    // this.x："test.x"

        var o = {
          f : function(){ 
            return this.a + this.b; 
          }
        };
        var p = Object.create(o);
        p.a = 1;
        p.b = 4;
        console.log(p.f());             // 5            
        alert(p.__proto__===o);            // true

如果該方法存在于一個(gè)對(duì)象的原型鏈上，那么this指向的是調(diào)用這個(gè)方法的對(duì)象，表現(xiàn)得好像是這個(gè)方法就存在于這個(gè)對(duì)象上一樣。
在這個(gè)例子中，對(duì)象p沒(méi)有屬于它自己的f屬性，它的f屬性繼承自它的原型。但是這對(duì)于最終在o中找到f屬性的查找過(guò)程來(lái)說(shuō)沒(méi)有關(guān)系；查找過(guò)程首先從p.f的引用開(kāi)始，所以函數(shù)中的this指向p。也就是說(shuō)，因?yàn)?b>f是作為p的方法調(diào)用的，所以它的this指向了p。這是JavaScript的原型繼承中的一個(gè)有趣的特性。