<sub id="rrh1b"><menuitem id="rrh1b"></menuitem></sub>

    <th id="rrh1b"><address id="rrh1b"><dfn id="rrh1b"></dfn></address></th><th id="rrh1b"></th>

    <th id="rrh1b"></th>

    <sub id="rrh1b"></sub>

        <sub id="rrh1b"><meter id="rrh1b"></meter></sub>
        <address id="rrh1b"><menuitem id="rrh1b"><font id="rrh1b"></font></menuitem></address>

          首页»JavaScript»面试官问:JS的this指向

          面试官问:JS的this指向

          来源:若川 发布时间:2019-02-25 阅读?#38382;?span id="spanClickTotal">

          前言

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

          附上之前写文章写过的一段话:已经有很多关于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中,全局变量是?#20197;?#22312;顶层对象(浏览器是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》上卷的读者,应该知道书上将这种叫做默?#20064;?#23450;。
          对call,apply熟悉的读者会类比为:

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

          效果是一样的,call,apply作用之一就是用来修改函数中的this指向为第一个?#38382;?#30340;。
          第一个?#38382;?#26159;undefined或者null,非严格模式下,是指向window。严格模式下,就是指向第一个?#38382;?#21518;文详?#38468;?#37322;。
          经常有这类代码(回调函数),其实也是普通函数调用模式。

          var name = '轩辕Rowboat';
          setTimeout(function(){
              console.log(this.name);
          }, 0);
          // 语法
          setTimeout(fn | code, 0, arg1, arg2, ...)
          // 也可以是一串代码。也可以传递其他函数
          // 类比 setTimeout函数内部调用fn或者执?#20889;?#30721;`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);

          但往往会有以下场景,?#35759;?#35937;中的函数赋值成一个变量了。
          这样其实又变成普通函数了,所以使用普通函数的规则(默?#20064;?#23450;)。

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

          call、apply、bind 调用模式

          上文提到call、apply,这里详?#38468;?#35835;一下。先通过MDN认识下call和apply
          MDN 文档:Function.prototype.call()
          语法

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

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

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

          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?#38382;?#20889;成值类型。但还是需要知道这个知识。
          之前写过一篇文章:面试官问:能否模拟实现JS的call和apply方法
          就是利用对象上的函数this指向这个对象,来模拟实现call和apply的。?#34892;?#36259;的读者思考如?#38382;?#29616;,再去看看笔者的实现。

          bind和call和apply类似,第一个?#38382;?#20063;是修改this指向,只不过返回值是新函数,新函数也能当做构造函数(new)调用。
          MDN Function.prototype.bind

          bind()方法创建一个新的函数, ?#38381;?#20010;新函数被调用时this键值为其提供的值,其?#38382;?#21015;表前几项值为创建时指定的?#38382;?#24207;列。
          语法:
          fun.bind(thisArg[, arg1[, arg2[, ...]]])
          ?#38382;?br /> thisArg
          调用绑定函数时作为this?#38382;?#20256;递给目标函数的值。 如果使用new运算符构造绑定函数,则忽略该值。?#31508;?#29992;bind在setTimeout?#20889;?#24314;一个函数(作为回调提供)时,作为thisArg传递的任何原始值都将转换为object。如果没有提供绑定的?#38382;?#21017;执行作用域的this被视为新函数的thisArg。
          arg1, arg2, ...
          当绑定函数被调用时,这些?#38382;?#23558;置于实参之前传递给?#35805;?#23450;的方法。
          返回值
          返回由指定的this值和初始化?#38382;?#25913;造的原函数拷?#30784;?/blockquote>

          之前也写过一篇文章:面试官问:能否模拟实现JS的bind方法
          就是利用call和apply指向这个thisArg?#38382;?#26469;模拟实现bind的。?#34892;?#36259;的读者思考如?#38382;?#29616;,再去看看笔者的实现。

          构造函数调用模式

          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,如果?#23884;?#35937;{},则result?#23884;?#35937;{}

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

          之前也写了一篇文章面试官问:能否模拟实现JS的new操作符,是使用apply来把this指向到生成的新生成的对象上。?#34892;?#36259;的读者思考如?#38382;?#29616;,再去看看笔者的实现。

          原型链中的调用模式

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

          会发现这个似曾相识。这就?#23884;?#35937;上的方法调用模式。自然是指向生成的新对象。
          如果该对象继承?#20113;?#23427;对象。同样会通过原型链查找。
          上面代码使用
          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也是通过构造函数模拟实现的,是一种语法糖。

          箭头函数调用模式

          先看箭头函数?#25512;?#36890;函数的重要区别:

          1、没有自己的this、super、arguments和new.target绑定。
          2、不能使用new来调用。
          3、没有原型对象。
          4、不可以改变this的绑定。
          5、形参名称不能重?#30784;?/blockquote>

          箭头函数中没有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?#24405;?#22788;理函数调用

          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是指向绑定?#24405;?#30340;元素。
          一些浏览器,比如IE6~IE8下使用attachEvent,this指向是window。
          顺便提下:面试官也经常考察ev.currentTarget和ev.target的区别。
          ev.currentTarget?#21069;?#23450;?#24405;?#30340;元素,而ev.target是当前触发?#24405;?#30340;元素。比如这里的分别是ul和li。
          但也可能点击的是ul,这时ev.currentTarget和ev.target就相等了。

          内联?#24405;?#22788;理函数调用

          <button class="btn1" onclick="console.log(this === document.querySelector('.btn1'))">点?#24050;?lt;/button>
          <button onclick="console.log((function(){return this})());">再点?#24050;?lt;/button>

          第一个是button本身,所以是true,第二个是window。这里跟严格模式没有关系。
          ?#27604;?#25105;们现在不会这样用了,但有时不小心写成了这样,也需要了解。

          其实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执行一个函数。是没有问题的。
          ?#27426;?#20107;实上,这代码是报错的。运算符优先级是new比点号低,所以是执行new (Student.doSth.call)(person)
          而Function.prototype.call,虽然是一个函数(apply、bind也是函数),跟箭头函数一样,不能用new调用。所以报错了。

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

          这是因为函数内部有两个不同的方法:[[Call]]和[[Constructor]]。
          ?#31508;?#29992;普通函数调用时,[[Call]]会被执行。?#31508;?#29992;构造函数调用时,[[Constructor]]会被执行。call、apply、bind和箭头函数内部没有[[Constructor]]方法。

          从上面的例子可以看出普通函数调用优先级最低,其?#38382;嵌?#35937;上的函数。
          call(apply、bind)调用方式和new调用方式的优先级,在《你不知道的JavaScript》?#23884;?#27604;bind和new,引用了mdn的bind的ployfill实现,new调用时bind之后的函数,会忽略bind绑定的第一个?#38382;?mdn的实现其实还有一些问题,?#34892;?#36259;的读者,可以?#27425;?#20043;前的文章:面试官问:能否模拟实现JS的bind方法),说明new的调用的优先级最高。
          所以它们的优先级是new 调用 > call、apply、bind 调用 > 对象上的函数调用 > 普通函数调用。

          总结

          如果要判断一个运行中函数的 this 绑定, 就需要?#19994;?#36825;个函数的直接调用位置。 ?#19994;?#20043;后
          就可以顺序应用下面这四条规则来判断 this 的绑定对象。

          1. new 调用:绑定到新创建的对象,注意?#21512;?#31034;return函数或对象,返回值不是新创建的对象,而是显式返回的函数或对象。
          2. call 或者 apply( 或者 bind) 调用:严格模式下,绑定到指定的第一个?#38382;?#38750;严格模式下,null和undefined,指向全局对象(浏览器中是window),其余值指向被new Object()包装的对象。
          3. 对象上的函数调用:绑定到那个对象。
          4. 普通函数调用: 在严格模式下绑定到 undefined,否则绑定到全局对象。

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

          DOM?#24405;?#20989;数:一般指向绑定?#24405;?#30340;DOM元素,但有些情况绑定到全局对象(比如IE6~IE8的attachEvent)。

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

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

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

          QQ群:WEB开发者官方群(515171538),验证消息:10000
          微信群:?#26377;?#32534;微信 849023636 邀请您加入,验证消息:10000
          提示:更多精彩内容关注微信公众号:全栈开发者中?#27169;╢sder-com)
          网友评论(共0条评论) 正在载入评论......
          理智评论文明上网,拒绝恶意谩骂 发表评论 / 共0条评论
          登录会员中心
          彩运

            <sub id="rrh1b"><menuitem id="rrh1b"></menuitem></sub>

            <th id="rrh1b"><address id="rrh1b"><dfn id="rrh1b"></dfn></address></th><th id="rrh1b"></th>

            <th id="rrh1b"></th>

            <sub id="rrh1b"></sub>

                <sub id="rrh1b"><meter id="rrh1b"></meter></sub>
                <address id="rrh1b"><menuitem id="rrh1b"><font id="rrh1b"></font></menuitem></address>

                    <sub id="rrh1b"><menuitem id="rrh1b"></menuitem></sub>

                    <th id="rrh1b"><address id="rrh1b"><dfn id="rrh1b"></dfn></address></th><th id="rrh1b"></th>

                    <th id="rrh1b"></th>

                    <sub id="rrh1b"></sub>

                        <sub id="rrh1b"><meter id="rrh1b"></meter></sub>
                        <address id="rrh1b"><menuitem id="rrh1b"><font id="rrh1b"></font></menuitem></address>

                          体彩大乐透投注技巧 多乐彩11选5快彩乐 尊龙国际娱乐城官方网址 福彩3d出号走势图2元网 2019第105码报 一定牛彩票官网 体彩20选5浙江风采 四川快乐12电视走势图 nba球队英文名称和图标 山东七乐彩走势图 气排球网 福建省体彩开奖官方网站 腾讯围棋 一码中特香港 重庆幸运农场在线预测软件