写点什么

面试官问:JS 的 this 指向

作者:若川
  • 2022 年 6 月 27 日
  • 本文字数:7309 字

    阅读完需:约 24 分钟

前言

大家好,我是若川为了能帮助到更多对源码感兴趣、想学会看源码、提升自己前端技术能力的同学。我倾力最近组织了源码共读活动,已进行三个月,大家一起交流学习,共同进步,很多人都表示收获颇丰。


这是面试官问系列的第四篇,旨在帮助读者提升JS基础知识,包含new、call、apply、this、继承相关知识。<br>面试官问系列文章如下:感兴趣的读者可以点击阅读。<br>1.面试官问:能否模拟实现JS的new操作符<br>2.面试官问:能否模拟实现JS的bind方法<br>3.面试官问:能否模拟实现JS的call和apply方法<br>4.面试官问:JS的this指向<br>5.面试官问:JS的继承<br>


面试官出很多考题,基本都会变着方式来考察this指向,看候选人对JS基础知识是否扎实。读者可以先拉到底部看总结,再谷歌(或各技术平台)搜索几篇类似文章,看笔者写的文章和别人有什么不同(欢迎在评论区评论不同之处),对比来看,验证与自己现有知识是否有盲点,多看几篇,自然就会完善自身知识。


附上之前写文章写过的一段话:已经有很多关于this的文章,为什么自己还要写一遍呢。学习就好比是座大山,人们沿着不同的路登山,分享着自己看到的风景。你不一定能看到别人看到的风景,体会到别人的心情。只有自己去登山,才能看到不一样的风景,体会才更加深刻。<br>


函数的this在调用时绑定的,完全取决于函数的调用位置(也就是函数的调用方法)。为了搞清楚this的指向是什么,必须知道相关函数是如何调用的。

全局上下文

非严格模式和严格模式中 this 都是指向顶层对象(浏览器中是window)。


this === window // true'use strict'this === window;this.name = '若川';console.log(this.name); // 若川
复制代码

函数上下文

普通函数调用模式

// 非严格模式var name = 'window';var doSth = function(){    console.log(this.name);}doSth(); // 'window'
复制代码


你可能会误以为window.doSth()是调用的,所以是指向window。虽然本例中window.doSth确实等于doSthname等于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》上卷的读者,应该知道书上将这种叫做默认绑定。对callapply熟悉的读者会类比为:


doSth.call(undefined);doSth.apply(undefined);
复制代码


效果是一样的,callapply作用之一就是用来修改函数中的this指向为第一个参数的。第一个参数是undefined或者null,非严格模式下,是指向window。严格模式下,就是指向第一个参数。后文详细解释。<br>经常有这类代码(回调函数),其实也是普通函数调用模式。


var name = '若川';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: '若川',    doSth: doSth,    other: {        name: 'other',        doSth: doSth,    }}student.doSth(); // '若川'student.other.doSth(); // 'other'// 用call类比则为:student.doSth.call(student);// 用call类比则为:student.other.doSth.call(student.other);
复制代码


但往往会有以下场景,把对象中的函数赋值成一个变量了。这样其实又变成普通函数了,所以使用普通函数的规则(默认绑定)。


var studentDoSth = student.doSth;studentDoSth(); // 'window'// 用call类比则为:studentDoSth.call(undefined);
复制代码

call、apply、bind 调用模式

上文提到callapply,这里详细解读一下。先通过MDN认识下callapplyMDN 文档:Function.prototype.call()<br>语法<br>


fun.call(thisArg, arg1, arg2, ...)
复制代码


thisArg<br>在fun函数运行时指定的this值。需要注意的是,指定的this值并不一定是该函数执行时真正的this值,如果这个函数处于非严格模式下,则指定为nullundefinedthis值会自动指向全局对象(浏览器中就是window对象),同时值为原始值(数字,字符串,布尔值)的this会指向该原始值的自动包装对象。<br>arg1, arg2, ...<br>指定的参数列表<br>返回值<br>返回值是你调用的方法的返回值,若该方法没有返回值,则返回undefined。<br>applycall类似。只是参数不一样。它的参数是数组(或者类数组)。


根据参数thisArg的描述,可以知道,call就是改变函数中的this指向为thisArg,并且执行这个函数,这也就使JS灵活很多。严格模式下,thisArg是原始值是值类型,也就是原始值。不会被包装成对象。举个例子:


var doSth = function(name){    console.log(this);    console.log(name);}doSth.call(2, '若川'); // Number{2}, '若川'var doSth2 = function(name){    'use strict';    console.log(this);    console.log(name);}doSth2.call(2, '若川'); // 2, '若川'
复制代码


虽然一般不会把thisArg参数写成值类型。但还是需要知道这个知识。之前写过一篇文章:面试官问:能否模拟实现JScallapply方法就是利用对象上的函数this指向这个对象,来模拟实现callapply的。感兴趣的读者思考如何实现,再去看看笔者的实现。


bindcallapply类似,第一个参数也是修改this指向,只不过返回值是新函数,新函数也能当做构造函数(new)调用。MDN Function.prototype.bind


bind()方法创建一个新的函数, 当这个新函数被调用时this键值为其提供的值,其参数列表前几项值为创建时指定的参数序列。<br>语法:fun.bind(thisArg[, arg1[, arg2[, ...]]])<br>参数:thisArg 调用绑定函数时作为 this 参数传递给目标函数的值。 如果使用new运算符构造绑定函数,则忽略该值。当使用bindsetTimeout中创建一个函数(作为回调提供)时,作为thisArg传递的任何原始值都将转换为object。如果没有提供绑定的参数,则执行作用域的this被视为新函数的thisArgarg1, arg2, ...当绑定函数被调用时,这些参数将置于实参之前传递给被绑定的方法。返回值返回由指定的this值和初始化参数改造的原函数拷贝。


之前也写过一篇文章:面试官问:能否模拟实现JSbind方法就是利用callapply指向这个thisArg参数,来模拟实现bind的。感兴趣的读者思考如何实现,再去看看笔者的实现。

构造函数调用模式

function Student(name){    this.name = name;    console.log(this); // {name: '若川'}    // 相当于返回了    // return this;}var result = new Student('若川');
复制代码


使用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('若川');console.log(result); {name: '若川'}// 如果返回函数f,则result是函数f,如果是对象{},则result是对象{}
复制代码


很多人或者文章都忽略了这一点,直接简单用typeof判断对象。虽然实际使用时不会显示返回,但面试官会问到。


之前也写了一篇文章面试官问:能否模拟实现JSnew操作符,是使用 apply 来把 this 指向到生成的新生成的对象上。感兴趣的读者思考如何实现,再去看看笔者的实现。

原型链中的调用模式

function Student(name){    this.name = name;}var s1 = new Student('若川');Student.prototype.doSth = function(){    console.log(this.name);}s1.doSth(); // '若川'
复制代码


会发现这个似曾相识。这就是对象上的方法调用模式。自然是指向生成的新对象。如果该对象继承自其它对象。同样会通过原型链查找。上面代码使用ES6class写法则是:


class Student{    constructor(name){        this.name = name;    }    doSth(){        console.log(this.name);    }}let s1 = new Student('若川');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('若川');s1.doSth();
复制代码


由此看出,ES6class也是通过构造函数模拟实现的,是一种语法糖。

箭头函数调用模式

先看箭头函数和普通函数的重要区别:


1、没有自己的thissuperargumentsnew.target绑定。2、不能使用new来调用。3、没有原型对象。4、不可以改变this的绑定。5、形参名称不能重复。


箭头函数中没有this绑定,必须通过查找作用域链来决定其值。如果箭头函数被非箭头函数包含,则this绑定的是最近一层非箭头函数的this,否则this的值则被设置为全局对象。比如:


var name = 'window';var student = {    name: '若川',    doSth: function(){        // var self = this;        var arrowDoSth = () => {            // console.log(self.name);            console.log(this.name);        }        arrowDoSth();    },    arrowDoSth2: () => {        console.log(this.name);    }}student.doSth(); // '若川'student.arrowDoSth2(); // 'window'
复制代码


其实就是相当于箭头函数外的this是缓存的该箭头函数上层的普通函数的this。如果没有普通函数,则是全局对象(浏览器中则是window)。也就是说无法通过callapplybind绑定箭头函数的this(它自身没有this)。而callapplybind可以绑定缓存箭头函数上层的普通函数的this。比如:


var student = {    name: '若川',    doSth: function(){        console.log(this.name);        return () => {            console.log('arrowFn:', this.name);        }    }}var person = {    name: 'person',}student.doSth().call(person); // '若川'  'arrowFn:' '若川'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>
复制代码


onclickaddEventerListener是指向绑定事件的元素。一些浏览器,比如IE6~IE8下使用attachEventthis指向是window。顺便提下:面试官也经常考察ev.currentTargetev.target的区别。ev.currentTarget是绑定事件的元素,而ev.target是当前触发事件的元素。比如这里的分别是ulli。但也可能点击的是ul,这时ev.currentTargetev.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中的gettersetterthisnew 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: '若川',    doSth: doSth,}// 普通函数调用doSth(); // window// 对象上的函数调用Student.doSth(); // '若川'// 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,虽然是一个函数(applybind也是函数),跟箭头函数一样,不能用new调用。所以报错了。


Uncaught TypeError: Student.doSth.call is not a constructor
复制代码


这是因为函数内部有两个不同的方法:[[Call]][[Constructor]]。当使用普通函数调用时,[[Call]]会被执行。当使用构造函数调用时,[[Constructor]]会被执行。callapplybind和箭头函数内部没有[[Constructor]]方法。


从上面的例子可以看出普通函数调用优先级最低,其次是对象上的函数。call(apply、bind)调用方式和new调用方式的优先级,在《你不知道的 JavaScript》是对比bindnew,引用了mdnbindployfill实现,new调用时 bind 之后的函数,会忽略bind绑定的第一个参数,(mdn的实现其实还有一些问题,感兴趣的读者,可以看我之前的文章:面试官问:能否模拟实现JSbind方法),说明new的调用的优先级最高。所以它们的优先级是new 调用 > call、apply、bind 调用 > 对象上的函数调用 > 普通函数调用。

总结

如果要判断一个运行中函数的 this 绑定, 就需要找到这个函数的直接调用位置。 找到之后就可以顺序应用下面这四条规则来判断 this 的绑定对象。<br>


  1. new 调用:绑定到新创建的对象,注意:显示return函数或对象,返回值不是新创建的对象,而是显式返回的函数或对象。<br>

  2. call 或者 apply( 或者 bind) 调用:严格模式下,绑定到指定的第一个参数。非严格模式下,nullundefined,指向全局对象(浏览器中是window),其余值指向被new Object()包装的对象。<br>

  3. 对象上的函数调用:绑定到那个对象。<br>

  4. 普通函数调用: 在严格模式下绑定到 undefined,否则绑定到全局对象。<br>


ES6 中的箭头函数:不会使用上文的四条标准的绑定规则, 而是根据当前的词法作用域来决定this, 具体来说, 箭头函数会继承外层函数,调用的 this 绑定( 无论 this 绑定到什么),没有外层函数,则是绑定到全局对象(浏览器中是window)。 这其实和 ES6 之前代码中的 self = this 机制一样。


DOM事件函数:一般指向绑定事件的DOM元素,但有些情况绑定到全局对象(比如IE6~IE8attachEvent)。


一定要注意,有些调用可能在无意中使用普通函数绑定规则。 如果想“ 更安全” 地忽略 this 绑定, 你可以使用一个对象, 比如 ø = Object.create(null), 以保护全局对象。


面试官考察this指向就可以考察new、call、apply、bind,箭头函数等用法。从而扩展到作用域、闭包、原型链、继承、严格模式等。这就是面试官乐此不疲的原因。


读者发现有不妥或可改善之处,欢迎指出。另外觉得写得不错,可以点个赞,也是对笔者的一种支持。

考题

this指向考题经常结合一些运算符等来考察。看完本文,不妨通过以下两篇面试题测试一下。<br>小小沧海:一道常被人轻视的前端JS面试题<br>从这两套题,重新认识JS的this、作用域、闭包、对象

扩展阅读

你不知道的JavaScript 上卷<br>冴羽:JavaScript深入之从ECMAScript规范解读this<br>这波能反杀:前端基础进阶(五):全方位解读this<br>


最后可以持续关注我 @若川。欢迎与我交流,参与 源码共读 活动,每周大家一起学习 200 行左右的源码,共同进步。


发布于: 刚刚阅读数: 5
用户头像

若川

关注

还未添加个人签名 2018.09.11 加入

https://lxchuan12.gitee.io

评论

发布
暂无评论
面试官问:JS的this指向_JavaScript_若川_InfoQ写作社区