面试官问：JS的this指向

jiezi

6 年前

面试官经常会出很多考题，都会考察 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 和 applyMDN 文档：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 操作符调用函数，会自动执行以下步骤。

创建了一个全新的对象。
这个对象会被执行[[Prototype]]（也就是__proto__）链接。
生成的新对象会绑定到函数调用的 this。
通过 new 创建的每个对象将最终被 [[Prototype]] 链接到这个函数的 prototype 对象上。
如果函数没有返回对象类型 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 的结果
‘use strict’;

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;
}();

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 的绑定对象。

new 调用：绑定到新创建的对象，注意：显示 return 函数或对象，返回值不是新创建的对象，而是显式返回的函数或对象。

call 或者 apply（或者 bind）调用：严格模式下，绑定到指定的第一个参数。非严格模式下，null 和 undefined，指向全局对象（浏览器中是 window），其余值指向被 new Object()包装的对象。
对象上的函数调用：绑定到那个对象。
普通函数：在严格模式下绑定到 undefined，否则绑定到全局对象。

ES6 中的箭头函数：不会使用上文的四条标准的绑定规则，而是根据当前的词法作用域来决定 this，具体来说，箭头函数会继承外层函数，调用的 this 绑定（无论 this 绑定到什么），没有外层函数，则是绑定到全局对象（浏览器中是 window）。这其实和 ES6 之前代码中的 self = this 机制一样。
DOM 事件函数：一般指向绑定事件的 DOM 元素，但有些情况绑定到全局对象（比如 IE6~IE8 的 attachEvent）。
一定要注意，有些调用可能在无意中使用普通函数绑定规则。如果想“更安全”地忽略 this 绑定，你可以使用一个对象，比如 ø = Object.create(null)，以保护全局对象。
面试官考察 this 指向就可以考察 new、call、apply、bind，箭头函数等用法。从而扩展到作用域、闭包、原型链、继承、严格模式等。这就是面试官乐此不疲的原因。
读者发现有不妥或可改善之处，欢迎指出。另外觉得写得不错，可以点个赞，也是对笔者的一种支持。
考题
this 指向考题经常结合一些运算符等来考察。看完本文，不妨通过以下两篇面试题测试一下。小小沧海：一道常被人轻视的前端 JS 面试题从这两套题，重新认识 JS 的 this、作用域、闭包、对象
扩展阅读
你不知道的 JavaScript 上卷冴羽：JavaScript 深入之从 ECMAScript 规范解读 this 这波能反杀：前端基础进阶（五）：全方位解读 this
关于
作者：常以轩辕 Rowboat 为名混迹于江湖。前端路上 | PPT 爱好者 | 所知甚少，唯善学。个人博客 segmentfault 前端视野专栏，开通了前端视野专栏，欢迎关注掘金个人主页，欢迎关注知乎前端视野专栏，开通了前端视野专栏，欢迎关注 github