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

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

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

最常用的函數(shù)調(diào)用類型：獨立函數(shù)調(diào)用。可以把這條規(guī)則看做是無法應用其他規(guī)則時的默認規(guī)則
舉例：

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

var a = 2

foo()   //2

在本例中。函數(shù)調(diào)用時應用了this的默認綁定，因此this指向全局對象。因為在代碼中，foo()是直接使用不帶任何修飾的函數(shù)引用進行調(diào)用的，因此只能默認綁定。

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

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

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

調(diào)用位置使用obj上下文來引用函數(shù)，隱式綁定規(guī)則會把函數(shù)調(diào)用中的this綁定在這個上下文對象中。
但是要注意隱式丟失：
被隱式綁定的函數(shù)會丟失綁定對象，也就是說它會應用默認綁定，從而綁定在全局對象或者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的綁定對象。
當傳入了一個基本類型值來當做this的綁定對象，這個值會被轉換成對應的對象形式，這通常被稱為“裝箱”。

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

這是一種顯式的強制綁定，因此稱為硬綁定
典型應用場景：

創(chuàng)建一個包裹函數(shù)，負責接收參數(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)建一個可以重復使用的輔助函數(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中，構造函數(shù)只是一些使用new操作符時被調(diào)用的函數(shù)，它們并不屬于哪一類，也不會實例化一個類。實際上，它們甚至都不能說是一種特殊的函數(shù)類型，它們只是被new操作符調(diào)用的普通函數(shù)而已。
使用new來調(diào)用函數(shù)，或者說發(fā)生構造函數(shù)調(diào)用時，會自動執(zhí)行下面的操作。

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

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

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

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

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

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

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

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

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

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

被忽略的this

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

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

var  a = 2

foo.call(undefined) //2

間接引用

你有可能有意無意的創(chuàng)建了一個函數(shù)的“間接引用”，在這種情況下，調(diào)用這個函數(shù)會應用默認綁定規(guī)則。
間接引用最容易在賦值時發(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

因為賦值表達式p.foo = o.foo的返回值時目標函數(shù)的引用，因此調(diào)用位置是foo()而不是p.foo()。

軟綁定

硬綁定會把this強制綁定到指定的對象（除了使用new時），防止函數(shù)調(diào)用應用默認綁定規(guī)則，但是硬綁定大大降低了函數(shù)的靈活性，使用硬綁定之后就無法使用隱式綁定或者顯式綁定來修改this,所以我們使用軟綁定，給默認綁定指定一個全局對象和undefined以外的值，就可以實現(xiàn)和硬綁定相同的效果，同時保留隱式綁定或者顯式綁定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關鍵字定義的，而是使用=>定義的，箭頭函數(shù)不適用this的四種標準規(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ù)中，例如事件處理器或者定時器

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機制。