摘要：通常尋找調(diào)用位置，最重要的是分析調(diào)用棧就是為了達(dá)到當(dāng)前執(zhí)行位置所調(diào)用的所有函數(shù)，而調(diào)用位置就是在當(dāng)前正在執(zhí)行的函數(shù)的前一個(gè)調(diào)用中。綁定在中，構(gòu)造函數(shù)只是一些使用操作符時(shí)被調(diào)用的函數(shù)，它們并不屬于哪一類，也不會實(shí)例化一個(gè)類。

每個(gè)函數(shù)的this是在調(diào)用時(shí)被綁定的，完全取決于函數(shù)的調(diào)用位置，
那么調(diào)用位置是什么？它是函數(shù)在代碼中被調(diào)用的位置。
通常尋找調(diào)用位置，最重要的是分析調(diào)用棧（就是為了達(dá)到當(dāng)前執(zhí)行位置所調(diào)用的所有函數(shù)），而調(diào)用位置就是在當(dāng)前正在執(zhí)行的函數(shù)的前一個(gè)調(diào)用中。
實(shí)例：

function baz() {
    // 當(dāng)前調(diào)用棧是：baz
    // 因此，當(dāng)前調(diào)用位置是全局作用域
    console.log("baz");
    bar(); // <-- bar 的調(diào)用位置
}
function bar() {
    // 當(dāng)前調(diào)用棧是 baz -> bar
    // 因此，當(dāng)前調(diào)用位置在 baz 中
    console.log("bar");
    foo(); // <-- foo 的調(diào)用位置
}
function foo() {
    // 當(dāng)前調(diào)用棧是 baz -> bar -> foo
    // 因此，當(dāng)前調(diào)用位置在 bar 中
    console.log("foo");
}
baz(); // <-- baz 的調(diào)用位置

最常用的函數(shù)調(diào)用類型：獨(dú)立函數(shù)調(diào)用?？梢园堰@條規(guī)則看做是無法應(yīng)用其他規(guī)則時(shí)的默認(rèn)規(guī)則
舉例：

function foo() {
    console.log(this.a)
}

var a = 2

foo()   //2

在本例中。函數(shù)調(diào)用時(shí)應(yīng)用了this的默認(rèn)綁定，因此this指向全局對象。因?yàn)樵诖a中，foo()是直接使用不帶任何修飾的函數(shù)引用進(jìn)行調(diào)用的，因此只能默認(rèn)綁定。

調(diào)用位置是否有上下文對象，或者說是否被某個(gè)對象擁有或者包含。
舉例：

function foo() {
    console.log(this.a)
}

var obj = {
    a: 2,
    foo: foo
}
obj.foo()   //2

調(diào)用位置使用obj上下文來引用函數(shù)，隱式綁定規(guī)則會把函數(shù)調(diào)用中的this綁定在這個(gè)上下文對象中。
但是要注意隱式丟失：
被隱式綁定的函數(shù)會丟失綁定對象，也就是說它會應(yīng)用默認(rèn)綁定，從而綁定在全局對象或者undefined中。舉例：

function foo() {
    console.log(this.a);
}
var obj = {
    a: 2,
    foo: foo
};
var bar = obj.foo; // 函數(shù)別名！
var a = "oops, global"; // a 是全局對象的屬性
bar(); // "oops, global"

使用函數(shù)的call()和apply()方法來直接指定this的綁定對象。
當(dāng)傳入了一個(gè)基本類型值來當(dāng)做this的綁定對象，這個(gè)值會被轉(zhuǎn)換成對應(yīng)的對象形式，這通常被稱為“裝箱”。

function foo() {
    console.log(this.a);
}
var obj = {
    a: 2,
};

var bar = function() {
    foo.call(obj)
}
bar()   //2
setTimeout(bar, 100)    //2
//硬綁定的bar無法改變它的this
bar.call(window)    //2

這是一種顯式的強(qiáng)制綁定，因此稱為硬綁定
典型應(yīng)用場景：

創(chuàng)建一個(gè)包裹函數(shù)，負(fù)責(zé)接收參數(shù)并返回值

function foo(something) {
    console.log(this.a, something);
    return this.a + something;
}
var obj = {
    a: 2
};
var bar = function () {
    return foo.apply(obj, arguments);
};
var b = bar(3); // 2 3
console.log(b); // 5

創(chuàng)建一個(gè)可以重復(fù)使用的輔助函數(shù)

function foo(something) {
    console.log(this.a, something);
    return this.a + something;
}
// 簡單的輔助綁定函數(shù)
function bind(fn, obj) {
    return function () {
        return fn.apply(obj, arguments);
    };
}
var obj = {
    a: 2
};
var bar = bind(foo, obj);
var b = bar(3); // 2 3
console.log(b); // 5

由于硬綁定是一種非常常用的模式，所以ES5提供了內(nèi)置的方法Function.prototype.bind方法。

在Javascript中，構(gòu)造函數(shù)只是一些使用new操作符時(shí)被調(diào)用的函數(shù)，它們并不屬于哪一類，也不會實(shí)例化一個(gè)類。實(shí)際上，它們甚至都不能說是一種特殊的函數(shù)類型，它們只是被new操作符調(diào)用的普通函數(shù)而已。
使用new來調(diào)用函數(shù)，或者說發(fā)生構(gòu)造函數(shù)調(diào)用時(shí)，會自動(dòng)執(zhí)行下面的操作。

創(chuàng)建（或者說構(gòu)造）一個(gè)全新的對象。

這個(gè)新對象會被執(zhí)行[[prototype]]連接。

這個(gè)新對象會綁定到函數(shù)調(diào)用的this。

如果函數(shù)沒有返回其他對象，那么new表達(dá)式中的函數(shù)調(diào)用會自動(dòng)返回這個(gè)新對象。

function foo(a) {
    this.a = a;
}
var bar = new foo(2);
console.log(bar.a); // 2

使用new來調(diào)用foo()時(shí)，我們會構(gòu)造一個(gè)新對象并把它綁定到foo()調(diào)用中的this上。new是最后一種可以影響函數(shù)調(diào)用時(shí)this綁定行為的方法，我們稱為new綁定。

函數(shù)是否在new中調(diào)用(new綁定)?如果是的話this綁定的是新創(chuàng)建的對象。

函數(shù)是否通過call、apply(顯式綁定)或者硬綁定調(diào)用？this綁定的是指定的對象。

函數(shù)是否在某個(gè)上下文對象中調(diào)用（隱式綁定）？this綁定的是那個(gè)上下文對象。

如果都不是的話，使用默認(rèn)綁定。如果在嚴(yán)格模式下，就綁定到undefined，否則綁定到全局對象。

被忽略的this

如果你把null或者undefined作為this的綁定對象傳入call，apply或者bind，這些值在調(diào)用時(shí)會被忽略，實(shí)際應(yīng)用的是默認(rèn)綁定規(guī)則：

function foo() {
    console.log(this.a)
}

var  a = 2

foo.call(undefined) //2

間接引用

你有可能有意無意的創(chuàng)建了一個(gè)函數(shù)的“間接引用”，在這種情況下，調(diào)用這個(gè)函數(shù)會應(yīng)用默認(rèn)綁定規(guī)則。
間接引用最容易在賦值時(shí)發(fā)生：

function foo() {
    console.log(this.a)
}

var a = 2;
var o = {a: 3, foo: foo}
var p = {a: 4}
o.foo()     // 3
(p.foo = o.foo)()       //2

因?yàn)橘x值表達(dá)式p.foo = o.foo的返回值時(shí)目標(biāo)函數(shù)的引用，因此調(diào)用位置是foo()而不是p.foo()。

軟綁定

硬綁定會把this強(qiáng)制綁定到指定的對象（除了使用new時(shí)），防止函數(shù)調(diào)用應(yīng)用默認(rèn)綁定規(guī)則，但是硬綁定大大降低了函數(shù)的靈活性，使用硬綁定之后就無法使用隱式綁定或者顯式綁定來修改this,所以我們使用軟綁定，給默認(rèn)綁定指定一個(gè)全局對象和undefined以外的值，就可以實(shí)現(xiàn)和硬綁定相同的效果，同時(shí)保留隱式綁定或者顯式綁定this的能力。

if(!Function.prototype.softBind) {
    Funciton.prototype.softBind = function(obj) {
        var fn = this
        var curried = [].slice.call(arguments, 1)
        var bound = function() {
            return fn.apply(
                (!this || this === (window || global)) ? obj : this,
                curried.concat.apply(curried, arguments)
                )
            )
        }

        bound.prototype = Object.create(fn.prototype)
        return bound
    }
}

ES6中介紹了一種無法使用上面那些規(guī)則的特殊函數(shù)類型：箭頭函數(shù)。
箭頭函數(shù)并不是function關(guān)鍵字定義的，而是使用=>定義的，箭頭函數(shù)不適用this的四種標(biāo)準(zhǔn)規(guī)則，而是根據(jù)外層（函數(shù)或者全局）作用域來決定this的

function foo() {
    return (a) => {
        console.log(this.a)
    }
}

var obj1 = {
    a: 2
}

var obj2 = {
    a: 3
}

var bar = foo.call(obj1)
bar.call(obj2)      //2，不是3

箭頭函數(shù)最常用域回調(diào)函數(shù)中，例如事件處理器或者定時(shí)器

function foo() {
    setTimeout(() => {
        console.log(this.a)
    }, 100)
}

var obj = {a: 2}
foo.call(obj)   // 2

箭頭函數(shù)像bind一樣確保函數(shù)的this被綁定到指定對象上，此外，其重要性還體現(xiàn)在它用更常見的詞法作用域取代了傳統(tǒng)的this機(jī)制。