首頁»JavaScript»面試官問:JS的this指向

面試官問:JS的this指向

來源:若川 發布時間:2019-02-25 閱讀次數:

前言

面試官出很多考題,基本都會變著方式來考察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,箭頭函數等用法。從而擴展到作用域、閉包、原型鏈、繼承、嚴格模式等。這就是面試官樂此不疲的原因。

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

QQ群:WEB開發者官方群(515171538),驗證消息:10000
微信群:加小編微信 849023636 邀請您加入,驗證消息:10000
提示:更多精彩內容關注微信公眾號:全棧開發者中心(fsder-com)
網友評論(共0條評論) 正在載入評論......
理智評論文明上網,拒絕惡意謾罵 發表評論 / 共0條評論
登錄會員中心
分分中彩票app 营口市| 普陀区| 德钦县| 安仁县| 右玉县| 桃源县| 绥德县| 丽水市| 革吉县| 新乡市| 弥渡县| 漳州市| 阳曲县| 卓尼县| 通城县| 南乐县| 平远县| 闸北区| 康定县| 建宁县| 壤塘县| 霸州市| 福建省| 杭锦旗| 株洲县| 灵宝市| 富蕴县| 六枝特区| 泊头市| 舒兰市| 黄平县| 张家口市| 太原市| 应城市| 襄樊市| 舟山市| 新巴尔虎右旗| 且末县|