面試官問：JS的this指向

前言

面試官出很多考題，基本都會變著方式來考察this指向，看候選人對JS基礎知識是否紮實。
讀者可以先拉到底部看總結，再谷歌（或各技術平臺）搜尋幾篇類似文章，看筆者寫的文章和別人有什麼不同（歡迎在評論區評論不同之處），對比來看，驗證與自己現有知識是否有盲點，多看幾篇，自然就會完善自身知識。

附上之前寫文章寫過的一段話：已經有很多關於this的文章，為什麼自己還要寫一遍呢。學習就好比是座大山，人們沿著不同的路登山，分享著自己看到的風景。你不一定能看到別人看到的風景，體會到別人的心情。只有自己去登山，才能看到不一樣的風景，體會才更加深刻。

函式的this在呼叫時繫結的，完全取決於函式的呼叫位置（也就是函式的呼叫方法）。為了搞清楚this的指向是什麼，必須知道相關函式是如何呼叫的。

全域性上下文

非嚴格模式和嚴格模式中this都是指向頂層物件（瀏覽器中是window）。

this === window // true
'use strict'
this === window;
this.name = '軒轅Rowboat';
console.log(this.name); // 軒轅Rowboat

函式上下文

普通函式呼叫模式

// 非嚴格模式
var name = 'window';
var doSth = function(){
    console.log(this.name);
}
doSth(); // 'window'

你可能會誤以為window.doSth()是呼叫的，所以是指向window。雖然本例中window.doSth確實等於doSth。name等於window.name。上面程式碼中這是因為在ES5中，全域性變數是掛載在頂層物件（瀏覽器是window）中。
事實上，並不是如此。

// 非嚴格模式
let name2 = 'window2';
let doSth2 = function(){
    console.log(this === window);
    console.log(this.name2);
}
doSth2() // true, undefined

這個例子中let沒有給頂層物件中（瀏覽器是window）新增屬性，window.name2和window.doSth都是undefined。

嚴格模式中，普通函式中的this則表現不同，表現為undefined。

// 嚴格模式
'use strict'
var name = 'window';
var doSth = function(){
    console.log(typeof this === 'undefined');
    console.log(this.name);
}
doSth(); // true，// 報錯，因為this是undefined

看過的《你不知道的JavaScript》上卷的讀者，應該知道書上將這種叫做預設繫結。
對call，apply熟悉的讀者會類比為：

doSth.call(undefined);
doSth.apply(undefined);

效果是一樣的，call，apply作用之一就是用來修改函式中的this指向為第一個引數的。
第一個引數是undefined或者null，非嚴格模式下，是指向window。嚴格模式下，就是指向第一個引數。後文詳細解釋。
經常有這類程式碼（回撥函式），其實也是普通函式呼叫模式。

var name = '軒轅Rowboat';
setTimeout(function(){
    console.log(this.name);
}, 0);
// 語法
setTimeout(fn | code, 0, arg1, arg2, ...)
// 也可以是一串程式碼。也可以傳遞其他函式
// 類比 setTimeout函式內部呼叫fn或者執行程式碼`code`。
fn.call(undefined, arg1, arg2, ...);

物件中的函式（方法）呼叫模式

var name = 'window';
var doSth = function(){
    console.log(this.name);
}
var student = {
    name: '軒轅Rowboat',
    doSth: doSth,
    other: {
        name: 'other',
        doSth: doSth,
    }
}
student.doSth(); // '軒轅Rowboat'
student.other.doSth(); // 'other'
// 用call類比則為：
student.doSth.call(student);
// 用call類比則為：
student.other.doSth.call(student);

但往往會有以下場景，把物件中的函式賦值成一個變數了。
這樣其實又變成普通函式了，所以使用普通函式的規則（預設繫結）。

var studentDoSth = student.doSth;
studentDoSth(); // 'window'
// 用call類比則為：
studentDoSth.call(undefined);

call、apply、bind 呼叫模式

上文提到call、apply，這裡詳細解讀一下。先通過MDN認識下call和apply
MDN 文件：Function.prototype.call()
語法

fun.call(thisArg, arg1, arg2, ...)

thisArg
在fun函式執行時指定的this值。需要注意的是，指定的this值並不一定是該函式執行時真正的this值，如果這個函式處於非嚴格模式下，則指定為null和undefined的this值會自動指向全域性物件(瀏覽器中就是window物件)，同時值為原始值(數字，字串，布林值)的this會指向該原始值的自動包裝物件。
arg1, arg2, ...
指定的引數列表
返回值
返回值是你呼叫的方法的返回值，若該方法沒有返回值，則返回undefined。
apply和call類似。只是引數不一樣。它的引數是陣列（或者類陣列）。

根據引數thisArg的描述，可以知道，call就是改變函式中的this指向為thisArg，並且執行這個函式，這也就使JS靈活很多。嚴格模式下，thisArg是原始值是值型別，也就是原始值。不會被包裝成物件。舉個例子：

var doSth = function(name){
    console.log(this);
    console.log(name);
}
doSth.call(2, '軒轅Rowboat'); // Number{2}, '軒轅Rowboat'
var doSth2 = function(name){
    'use strict';
    console.log(this);
    console.log(name);
}
doSth2.call(2, '軒轅Rowboat'); // 2, '軒轅Rowboat'

雖然一般不會把thisArg引數寫成值型別。但還是需要知道這個知識。
之前寫過一篇文章：面試官問：能否模擬實現JS的call和apply方法
就是利用物件上的函式this指向這個物件，來模擬實現call和apply的。感興趣的讀者思考如何實現，再去看看筆者的實現。

bind和call和apply類似，第一個引數也是修改this指向，只不過返回值是新函式，新函式也能當做建構函式（new）呼叫。
MDN Function.prototype.bind

bind()方法建立一個新的函式， 當這個新函式被呼叫時this鍵值為其提供的值，其引數列表前幾項值為建立時指定的引數序列。
語法：
fun.bind(thisArg[, arg1[, arg2[, ...]]])
引數：
thisArg
呼叫繫結函式時作為this引數傳遞給目標函式的值。 如果使用new運算子構造繫結函式，則忽略該值。當使用bind在setTimeout中建立一個函式（作為回撥提供）時，作為thisArg傳遞的任何原始值都將轉換為object。如果沒有提供繫結的引數，則執行作用域的this被視為新函式的thisArg。
arg1, arg2, ...
當繫結函式被呼叫時，這些引數將置於實參之前傳遞給被繫結的方法。
返回值
返回由指定的this值和初始化引數改造的原函式拷貝。

之前也寫過一篇文章：面試官問：能否模擬實現JS的bind方法
就是利用call和apply指向這個thisArg引數，來模擬實現bind的。感興趣的讀者思考如何實現，再去看看筆者的實現。

建構函式呼叫模式

function Student(name){
    this.name = name;
    console.log(this); // {name: '軒轅Rowboat'}
    // 相當於返回了
    // return this;
}
var result = new Student('軒轅Rowboat');

使用new操作符呼叫函式，會自動執行以下步驟。

1. 建立了一個全新的物件。
2. 這個物件會被執行[[Prototype]]（也就是__proto__）連結。
3. 生成的新物件會繫結到函式呼叫的this。
4. 通過new建立的每個物件將最終被[[Prototype]]連結到這個函式的prototype物件上。
5. 如果函式沒有返回物件型別Object(包含Functoin, Array, Date, RegExg, Error)，那麼new表示式中的函式呼叫會自動返回這個新的物件。

由此可以知道：new操作符呼叫時，this指向生成的新物件。
特別提醒一下，new呼叫時的返回值，如果沒有顯式返回物件或者函式，才是返回生成的新物件。

function Student(name){
    this.name = name;
    // return function f(){};
    // return {};
}
var result = new Student('軒轅Rowboat');
console.log(result); {name: '軒轅Rowboat'}
// 如果返回函式f，則result是函式f，如果是物件{}，則result是物件{}

很多人或者文章都忽略了這一點，直接簡單用typeof判斷物件。雖然實際使用時不會顯示返回，但面試官會問到。

之前也寫了一篇文章面試官問：能否模擬實現JS的new操作符，是使用apply來把this指向到生成的新生成的物件上。感興趣的讀者思考如何實現，再去看看筆者的實現。

原型鏈中的呼叫模式

function Student(name){
    this.name = name;
}
var s1 = new Student('軒轅Rowboat');
Student.prototype.doSth = function(){
    console.log(this.name);
}
s1.doSth(); // '軒轅Rowboat'

會發現這個似曾相識。這就是物件上的方法呼叫模式。自然是指向生成的新物件。
如果該物件繼承自其它物件。同樣會通過原型鏈查詢。
上面程式碼使用
ES6中class寫法則是：

class Student{
    constructor(name){
        this.name = name;
    }
    doSth(){
        console.log(this.name);
    }
}
let s1 = new Student('軒轅Rowboat');
s1.doSth();

babel es6轉換成es5的結果，可以去babeljs網站轉換測試自行試試。

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Student = function () {
    function Student(name) {
        _classCallCheck(this, Student);

        this.name = name;
    }

    _createClass(Student, [{
        key: 'doSth',
        value: function doSth() {
            console.log(this.name);
        }
    }]);

    return Student;
}();

var s1 = new Student('軒轅Rowboat');
s1.doSth();

由此看出，ES6的class也是通過建構函式模擬實現的，是一種語法糖。

箭頭函式呼叫模式

先看箭頭函式和普通函式的重要區別：

1、沒有自己的this、super、arguments和new.target繫結。
2、不能使用new來呼叫。
3、沒有原型物件。
4、不可以改變this的繫結。
5、形參名稱不能重複。

箭頭函式中沒有this繫結，必須通過查詢作用域鏈來決定其值。
如果箭頭函式被非箭頭函式包含，則this繫結的是最近一層非箭頭函式的this，否則this的值則被設定為全域性物件。
比如：

var name = 'window';
var student = {
    name: '軒轅Rowboat',
    doSth: function(){
        // var self = this;
        var arrowDoSth = () => {
            // console.log(self.name);
            console.log(this.name);
        }
        arrowDoSth();
    },
    arrowDoSth2: () => {
        console.log(this.name);
    }
}
student.doSth(); // '軒轅Rowboat'
student.arrowDoSth2(); // 'window'

其實就是相當於箭頭函式外的this是快取的該箭頭函式上層的普通函式的this。如果沒有普通函式，則是全域性物件（瀏覽器中則是window）。
也就是說無法通過call、apply、bind繫結箭頭函式的this(它自身沒有this)。而call、apply、bind可以繫結快取箭頭函式上層的普通函式的this。
比如：

var student = {
    name: '軒轅Rowboat',
    doSth: function(){
        console.log(this.name);
        return () => {
            console.log('arrowFn:', this.name);
        }
    }
}
var person = {
    name: 'person',
}
student.doSth().call(person); // '軒轅Rowboat'  'arrowFn:' '軒轅Rowboat'
student.doSth.call(person)(); // 'person' 'arrowFn:' 'person'

DOM事件處理函式呼叫

addEventerListener、attachEvent、onclick

<button class="button">onclick</button>
<ul class="list">
    <li>1</li>
    <li>2</li>
    <li>3</li>
</ul>
<script>
    var button = document.querySelector('button');
    button.onclick = function(ev){
        console.log(this);
        console.log(this === ev.currentTarget); // true
    }
    var list = document.querySelector('.list');
    list.addEventListener('click', function(ev){
        console.log(this === list); // true
        console.log(this === ev.currentTarget); // true
        console.log(this);
        console.log(ev.target);
    }, false);
</script>

onclick和addEventerListener是指向繫結事件的元素。
一些瀏覽器，比如IE6~IE8下使用attachEvent，this指向是window。
順便提下：面試官也經常考察ev.currentTarget和ev.target的區別。
ev.currentTarget是繫結事件的元素，而ev.target是當前觸發事件的元素。比如這裡的分別是ul和li。
但也可能點選的是ul，這時ev.currentTarget和ev.target就相等了。

內聯事件處理函式呼叫

<button class="btn1" onclick="console.log(this === document.querySelector('.btn1'))">點我呀</button>
<button onclick="console.log((function(){return this})());">再點我呀</button>

第一個是button本身，所以是true，第二個是window。這裡跟嚴格模式沒有關係。
當然我們現在不會這樣用了，但有時不小心寫成了這樣，也需要了解。

其實this的使用場景還有挺多，比如物件object中的getter、setter的this，new Function()、eval。
但掌握以上幾種，去分析其他的，就自然迎刃而解了。
使用比較多的還是普通函式呼叫、物件的函式呼叫、new呼叫、call、apply、bind呼叫、箭頭函式呼叫。
那麼他們的優先順序是怎樣的呢。

優先順序

而箭頭函式的this是上層普通函式的this或者是全域性物件（瀏覽器中是window），所以排除，不算優先順序。

var name = 'window';
var person = {
    name: 'person',
}
var doSth = function(){
    console.log(this.name);
    return function(){
        console.log('return:', this.name);
    }
}
var Student = {
    name: '軒轅Rowboat',
    doSth: doSth,
}
// 普通函式呼叫
doSth(); // window
// 物件上的函式呼叫
Student.doSth(); // '軒轅Rowboat'
// call、apply 呼叫
Student.doSth.call(person); // 'person'
new Student.doSth.call(person);

試想一下，如果是Student.doSth.call(person)先執行的情況下，那new執行一個函式。是沒有問題的。
然而事實上，這程式碼是報錯的。運算子優先順序是new比點號低，所以是執行new (Student.doSth.call)(person)
而Function.prototype.call，雖然是一個函式（apply、bind也是函式），跟箭頭函式一樣，不能用new呼叫。所以報錯了。

Uncaught TypeError: Student.doSth.call is not a constructor

這是因為函式內部有兩個不同的方法：[[Call]]和[[Constructor]]。
當使用普通函式呼叫時，[[Call]]會被執行。當使用建構函式呼叫時，[[Constructor]]會被執行。call、apply、bind和箭頭函式內部沒有[[Constructor]]方法。

從上面的例子可以看出普通函式呼叫優先順序最低，其次是物件上的函式。
call（apply、bind）呼叫方式和new呼叫方式的優先順序，在《你不知道的JavaScript》是對比bind和new，引用了mdn的bind的ployfill實現，new呼叫時bind之後的函式，會忽略bind繫結的第一個引數，(mdn的實現其實還有一些問題，感興趣的讀者，可以看我之前的文章：面試官問：能否模擬實現JS的bind方法)，說明new的呼叫的優先順序最高。
所以它們的優先順序是new 呼叫 > call、apply、bind 呼叫 > 物件上的函式呼叫 > 普通函式呼叫。

總結

如果要判斷一個執行中函式的 this 繫結， 就需要找到這個函式的直接呼叫位置。 找到之後
就可以順序應用下面這四條規則來判斷 this 的繫結物件。

1. new 呼叫：繫結到新建立的物件，注意：顯示return函式或物件，返回值不是新建立的物件，而是顯式返回的函式或物件。
2. call 或者 apply（ 或者 bind） 呼叫：嚴格模式下，繫結到指定的第一個引數。非嚴格模式下，null和undefined，指向全域性物件（瀏覽器中是window），其餘值指向被new Object()包裝的物件。
3. 物件上的函式呼叫：繫結到那個物件。
4. 普通函式呼叫： 在嚴格模式下繫結到 undefined，否則繫結到全域性物件。

ES6 中的箭頭函式：不會使用上文的四條標準的繫結規則， 而是根據當前的詞法作用域來決定this， 具體來說， 箭頭函式會繼承外層函式，呼叫的 this 繫結（ 無論 this 繫結到什麼），沒有外層函式，則是繫結到全域性物件（瀏覽器中是window）。 這其實和 ES6 之前程式碼中的 self = this 機制一樣。

DOM事件函式：一般指向繫結事件的DOM元素，但有些情況繫結到全域性物件（比如IE6~IE8的attachEvent）。

一定要注意，有些呼叫可能在無意中使用普通函式繫結規則。 如果想“ 更安全” 地忽略 this 綁
定， 你可以使用一個物件， 比如 ø = Object.create(null)， 以保護全域性物件。

面試官考察this指向就可以考察new、call、apply、bind，箭頭函式等用法。從而擴充套件到作用域、閉包、原型鏈、繼承、嚴格模式等。這就是面試官樂此不疲的原因。

讀者發現有不妥或可改善之處，歡迎指出。另外覺得寫得不錯，可以點個贊，也是對筆者的一種支援。