這裡有一個微妙但是非常重要的細節，雖然 this 的繫結規則完全取決於呼叫位置，但是隻有 foo() 執行在非 strict mode 下時，預設繫結才能繫結到全域性物件；嚴格模式下與 foo()的呼叫位置無關：

function foo() {
　　　　　console.log( this.a );
　　}
　　var a = 2;
　　(function(){
　　　　"use strict";
　　　　foo(); // 2
　　})();

b.隱式繫結

 首先，我們來看一段程式碼：

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

 我們可以看出，foo()函式的宣告方式和最後的obj中作為引用屬性新增到obj裡，但即使是這樣，嚴格意義上來說，foo()也不屬於obj物件，就算我們把宣告放入obj中，亦是如此。然而，呼叫位置會使用 obj 上下文來引用函式，因此你可以說函式被呼叫時 obj 物件“擁
有”或者“包含”它。

但是無論如何去稱呼這個模式，當foo()被呼叫的時候，指向確實指到了obj物件。當函式引用有上下文物件時，隱式繫結規則會把函式呼叫中的 this 繫結到這個上下文物件。因為呼叫 foo() 時 this 被繫結到 obj ，因此 this.a 和 obj.a 是一樣的。

這裡還會出現一個問題，隱式丟失。

function foo() {
    　　console.log( this.a );
　　}
　　var obj = {
    　　a: 2,
    　　foo: foo
　　};
　　var bar = obj.foo; // 函式別名！
　　var a = "Kevin"; // a 是全域性物件的屬性
　　bar(); // "Kevin"

來看這個例子，雖然bar是obj.foo的一個引用，但是實際上引用的卻是foo這個函式本身，所以此時，bar()是一個沒有任何修飾的函式呼叫，自然就應用了預設規則進行繫結。

還有一種情況，十分常見，也會出現隱式丟失，那就是在回撥函式中。來看下例子：

function foo() {
   　　 console.log( this.a );
　　}
　　var obj = {
   　　 a: 2,
    　　foo: foo
　　};
　　var a = "Kevin"; // a 是全域性物件的屬性
　　setTimeout( obj.foo, 100 ); // "Kevin"

引數傳遞其實就是一種隱式賦值，因此我們傳入函式時也會被隱式賦值，所以結果和上一個例子一樣。就像我們看到的那樣，回撥函式丟失 this 繫結是非常常見的。除此之外，還有一種情況 this 的行為會出乎我們意料：呼叫回撥函式的函式可能會修改 this 。無論是哪種情況， this 的改變都是意想不到的，實際上你無法控制回撥函式的執行方式，因此就沒有辦法控制會影響繫結的呼叫位置。

c.顯式繫結

在分析隱式繫結時，我們必須在一個物件內部包含一個指向函式的屬性，並通過這個屬性間接引用函式，從而把 this 間接（隱式）繫結到這個物件上。那麼如果我們不想在物件內部包含函式引用，而想在某個物件上強制呼叫函式，該怎麼做呢？這個時候，我們就需要使用call或者apply兩個方法來呼叫了。嚴格來說，JavaScript 的宿主環境有時會提供一些非常特殊的函式，它們並沒有這兩個方法。但是這樣的函式非常罕見，JavaScript 提供的絕大多數函式以及你自己建立的所有函式都可以使用 call(..) 和 apply(..) 方法。這兩個方法是如何工作的呢？它們的第一個引數是一個物件，它們會把這個物件繫結到this ，接著在呼叫函式時指定這個 this 。因為你可以直接指定 this 的繫結物件，因此我們稱之為顯式繫結。

來看下這個例子：

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

通過 foo.call(..) ，我們可以在呼叫 foo 時強制把它的 this 繫結到 obj 上。如果你傳入了一個原始值（字串型別、布林型別或者數字型別）來當作 this 的繫結物件，這個原始值會被轉換成它的物件形式（也就是 new String(..) 、 new Boolean(..) 或者new Number(..) ）。這通常被稱為“裝箱”。

但是即使這樣，也無法完全解決之前出現的繫結丟失的情況

1. 硬繫結
但是顯式繫結的一個變種可以解決這個問題。
我們來看這樣一個例子

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

 我們來看看這個變種到底是怎樣工作的。我們建立了函式 bar() ，並在它的內部手動呼叫了 foo.call(obj) ，因此強制把 foo 的 this 繫結到了 obj 。無論之後如何呼叫函式 bar ，它總會手動在 obj 上呼叫 foo 。這種繫結是一種顯式的強制繫結，因此我們稱之為硬繫結。硬繫結的典型應用場景就是建立一個包裹函式，傳入所有的引數並返回接收到的所有值：

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

 另一種使用方法是建立一個 i 可以重複使用的輔助函式：

function foo(something) {
　　　　console.log( this.a, something );
　　　　return this.a + something;
　　}
　　// 簡單的輔助繫結函式
　　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 中提供了內建的方法 Function.prototype.bind ，它的用法如下：

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

bind(..) 會返回一個硬編碼的新函式，它會把引數設定為 this 的上下文並呼叫原始函式。

2. API呼叫的“上下文”
第三方庫的許多函式，以及 JavaScript 語言和宿主環境中許多新的內建函式，都提供了一個可選的引數，通常被稱為“上下文”（context），其作用和 bind(..) 一樣，確保你的回撥函式使用指定的 this 。舉例來說：

function foo(el) {
        console.log( el, this.id );
    }
    var obj = {
        id: "awesome"
    };
    // 呼叫 foo(..) 時把 this 繫結到 obj
    [1, 2, 3].forEach( foo, obj ); // 1 awesome 2 awesome 3 awesome    

這些函式實際上就是通過 call(..) 或者 apply(..) 實現了顯式繫結，這樣你可以少些一些程式碼。

d.new繫結

這是第四條也是最後一條 this 的繫結規則，在講解它之前我們首先需要澄清一個非常常見的關於 JavaScript 中函式和物件的誤解。在傳統的面向類的語言中，“建構函式”是類中的一些特殊方法，使用 new 初始化類時會呼叫類中的建構函式。通常的形式是這樣的：

something = new MyClass(..);

JavaScript 也有一個 new 操作符，使用方法看起來也和那些面向類的語言一樣，絕大多數開發者都認為 JavaScript 中 new 的機制也和那些語言一樣。然而，JavaScript 中 new 的機制實際上和麵向類的語言完全不同。首先我們重新定義一下 JavaScript 中的“建構函式”。在 JavaScript 中，建構函式只是一些使用 new 操作符時被呼叫的函式。它們並不會屬於某個類，也不會例項化一個類。實際上，它們甚至都不能說是一種特殊的函式型別，它們只是被 new 操作符呼叫的普通函式而已。
舉例來說，思考一下 Number(..) 作為建構函式時的行為，ES5.1 中這樣描述它：

15.7.2　Number 建構函式當 Number 在 new 表示式中被呼叫時，它是一個建構函式：它會初始化新建立的物件。所以，包括內建物件函式（比如 Number(..) ，詳情請檢視第 3 章）在內的所有函式都可以用 new 來呼叫，這種函式呼叫被稱為建構函式呼叫。這裡有一個重要但是非常細微的區別：實際上並不存在所謂的“建構函式”，只有對於函式的“構造呼叫”。使用 new 來呼叫函式，或者說發生建構函式呼叫時，會自動執行下面的操作。

1. 建立（或者說構造）一個全新的物件。
2. 這個新物件會被執行 [[ 原型 ]] 連線。
3. 這個新物件會繫結到函式呼叫的 this 。
4. 如果函式沒有返回其他物件，那麼 new 表示式中的函式呼叫會自動返回這個新物件。
再來看看下面的例子

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

使用 new 來呼叫 foo(..) 時，我們會構造一個新物件並把它繫結到 foo(..) 呼叫中的 this上。 new 是最後一種可以影響函式呼叫時 this 繫結行為的方法，我們稱之為 new 繫結。

優先順序

有種情況我們需要進行考慮，就是在函式呼叫過程中，某個位置如果出現應用了多條繫結規則怎麼辦？那麼要解決這種問題，我們就需要知道規則的優先順序。

毫無疑問，預設規則是四條規則中最低的，所以暫時不做考慮。所以首先，我們需要比對一下顯式繫結與隱式繫結的優先順序，看看哪一個更高一些。

來看如下的例子：

function foo() {
    　　console.log( this.a );
　　}
　　var obj1 = {
    　　a: 2,
    　　foo: foo
　　};
　　var obj2 = {
    　　a: 3,
    　　foo: foo
　　};
　　obj1.foo(); // 2
　　obj2.foo(); // 3
　　obj1.foo.call( obj2 ); // 3
　　obj2.foo.call( obj1 ); // 2

 可以看到，顯式繫結優先順序更高，也就是說在判斷時應當先考慮是否可以應用顯式繫結。

接下來，我們需要比對下隱式和new的優先順序，看看誰高誰低。來看如下例子：

function foo(something) {
        this.a = something;
    }
    var obj1 = {
        foo: foo
    };
    var obj2 = {};
    obj1.foo( 2 );
    console.log( obj1.a ); // 2
    obj1.foo.call( obj2, 3 );
    console.log( obj2.a ); // 3
    var bar = new obj1.foo( 4 );
    console.log( obj1.a ); // 2
    console.log( bar.a ); // 4