前端面试之路——JS基础(二)this/call/apply/bind

·  阅读 498
前端面试之路——JS基础(二)this/call/apply/bind

前言

本篇文章,我们来总结归纳下万恶的this以及衍生出来的call/apply/bind对this进行绑定,想了很久,决定用实例演示的方式来讲解this,这样才能够理解this,因为this确实变化莫测,只靠概念,是不能够理解的;之后如果有看到更好的案例,也会同步更新到文章中。

总目录单击链接进行跳转:👉前端面试之路(目录)

this的绑定方式

首先我们要牢记于心this的指向,是在函数被调用的时候确定的,因此,this的指向便非常灵活,情况多样,常见的this一共有5种绑定方式:

  • 默认绑定(非严格模式下this指向全局对象, 严格模式下this会绑定到undefined)
  • 隐式绑定(当函数(fn)引用有上下文对象的时候, 如 obj.fn()的调用方式, fn内部的this是指向obj)
  • 显式绑定(通过call()或者apply()方法直接指定this的绑定对象)
  • new操作符(执行过程中会将新生成的对象绑定到函数调用的this)
  • 箭头函数绑定(this的指向由外层作用域环境决定的)

那让我们开始找到相应的题目,进行分析。

1.默认绑定

我们先来看默认绑定: 非严格模式下,this指向window,严格模式下this指向undefined,这句话其实有些歧义和令人不解的地方,我们通过几个题目来分析一下。

题目一:

var a = 1;
function fn () {
  console.log(this.a)
}
fn();
复制代码

我们知道,如果用var来声明变量(不在函数内)的话,会自动挂载到全局,全局调用函数,相当于是window调用了这个函数,所以上边这段代码相当于:

window.a = 1
function fn () {
  console.log(this.a)
}
window.fn()
复制代码

答案显而易见,输出为:

1
复制代码

而如果我们把var声明改为letconst,那么结果是什么呢?可以试一下,没错,是undefined,因为letconst声明的变量,不会被挂在到window对象中。

题目二:

"use strict";
var a = 1;
function fn () {
  console.log('inner-this', this)
  console.log(window.a)
  console.log(this.a)
}
console.log(window.fn)
console.log('outer-this', this)
fn();
复制代码

当我们在最上边写上use strict的时候,相当于开启了严格模式,但所谓的严格模式,只是将fn函数中的this指向了undefined,二并不会影响到全局的this指向,所以inner-this打印的是undefinedouter-this打印的是window对象,全局下使用var声明的变量a,依旧会被挂在到全局。

所以输出结果为:

image.png

2.隐式绑定

这种就是面试中经常出现的类型,那么对于判断这种this的指向,我们只需要记住哪个对象最后调用函数,函数中的this就指向那个对象(箭头函数除外)。 我们来看题目:

题目一:

function fn () {
  console.log(this.a)
}
var obj = { a: 1, fn }
var a = 2
obj.fn()
复制代码

我们利用上边的那句口诀,经过分析,发现最后调用fn的,是obj对象,所以,fn函数内部的this,便指向obj对象,答案显而易见输出:

1
复制代码

还有两种隐式绑定的情况,非常具有迷惑性,很容易绕晕,那就是将函数赋给一个新的变量,或者将函数作为参数,进行传递,我们还是通过几道题目来分析。

题目一:

function fn () {
  console.log(this.a)
};
var obj = { a: 1, fn };
var a = 2;
var fn2 = obj.fn;
var obj2 = { a: 3, fn2 }

obj.fn();
fn2();
obj2.fn2();
复制代码

先来判断obj.fn()的输出,没错,和上一题一样,很容易就能分析出此时this指向obj,输出1;而fn2被赋值成了obj.fn,在调用的时候,出现了隐式丢失,依旧是window来调用的,所以此时this指向window,输出2;再来分析obj2.fn2(),此时fn2是被obj2所调用了,又出现了隐式丢失,所以this指向obj2,输出3,最终结果为:

1
2
3
复制代码

题目二:

function foo () {
  console.log(this.a)
}
function fooWrapper (fn) {
  console.log(this)
  fn()
}
var obj = { a: 1, foo }
var a = 2
var obj2 = { a: 3, fooWrapper }

obj2.fooWrapper(obj.foo)
复制代码

我们来分析一下,这道题中,fooWrapper函数是被obj2对象所调用的,所以我们可以先得出fooWrapper中的this是指向obj2对象的,所以先打印出{ a: 3, fooWrapper: f }其实就是obj2这个对象;而obj.foo被当做参数传递到了fooWrapper中,此时是window调用的fn,所以,此时会输出2,最终结果为:

{ a: 3, fooWrapper: f } // 其实就是obj2这个对象
2
复制代码

所以我们可以得出结论在函数被当成参数传递进另一个函数时,会发生隐式丢失的问题,其this并不会受外层包裹它的函数所影响,非严格模式下指向window,严格模式下指向undefined,现在再看这句话,是不是比最开始看到,明白了很多了呢?同样的代码,可以在顶部加上use strict查看结果,来验证这句话。

3.显示绑定

就是使用一些方法,强行绑定函数内部this的指向,比如call apply bind,需要先注意下他们之间的区别:

  • 经由call()apply()绑定的函数,会直接调用执行;
  • call()apply()用法几乎相同,第一个参数都为绑定的对象,如果第一个参数为null或者undefined的话,会自动忽略这个参数;他们之间的区别就在于之后的传参方式:call接收多个参数,apply接收一个数组;
  • bind()绑定会生成一个新的函数,需要手动再次调用,才会执行;

我们先通过一个比较简单的题目来看下他们之间的区别,顺便温习一下call apply bind的基本用法:

题目一:

function fn (x, y) {
  console.log(this.a)
  console.log(x + y)
}
var obj = { a: 1 }
var a = 2

fn(5, 6)
fn.call(obj, 5, 6)
fn.apply(obj, [5, 6])
fn.bind(obj)(5, 6)
复制代码

首先fn被调用的时候,因为是window调用的fn,所以此时fn中的this指向window,从而打印1, 11;接下来的3种显示绑定,fn中的this便指向了obj,然后立即调用执行(bind因为返回的是一个函数,所以还需要手动加括号进行调用),结果都输出1,11;我们可以发现区别如上所述,就是传参方式不同。

题目二:

var obj1 = {
  a: 1
}
var obj2 = {
  a: 2,
  fn1: function () {
    console.log(this.a)
  },
  fn2: function () {
    setTimeout(function () {
      console.log(this)
      console.log(this.a)
    }.call(obj1), 0)
  }
}
var a = 3
obj2.fn1()
obj2.fn2()
复制代码

首先可以分析出obj2.fn1中,因为是ob2调用的fn1,所以fn1中的this指向obj2,首先输出2;再来看obj2.fn2,因为函数作为setTimeout的参数传入发生了隐式丢失,所以函数内部的this按理来说应该是指向window的,但是我们使用了call方法,改变了this指向为obj1,所以输出{ a: 1 } 1,最后输出结果为:

2
{ a: 1 } // 就是obj1对象自己
1
复制代码

题目三:

再来看一道返回匿名函数发生隐式丢失,与显示绑定结合的题目吧。

var obj = {
  a: 'obj',
  fn: function () {
    console.log('fn:', this.a)
    return function () {
      console.log('inner-a:', this.a)
    }
  }
}
var a = 'outer-a'
var obj2 = { a: 'obj2' }

obj.fn()()
obj.fn.call(obj2)()
obj.fn().call(obj2)
复制代码

看起来花里胡哨,我们只要仔细阅读,就不难分析出结果:

  • 首先看obj.fn()(),注意了,为啥是两个括号呢?其实是执行了2个操作,首先执行了obj.fn()函数,输出结果为fn: obj,之后,obj.fn()返回了一个匿名函数后,又执行了这个匿名函数,因为是window调用的,所以此时又会输出inner-a: outer-a
  • 之后再来看obj.fn.call(obj2)(),比较长,我们慢慢来看,首先obj.fn注意此时没加括号,说明obj.fn没有被调用,可以理解为找到了这个fn,之后使用call方法,给obj.fn进行显示绑定到obj2对象,所以,此时obj.fn中的this是指向obj2的,首先输出了fn: obj2,之后,又出现了一个括号,和上边一样,也是匿名函数此刻被调用了,依旧是window对齐进行的调用,所以此时又会输出inner-a: outer-a
  • 最后再来看obj.fn().call(obj2),会发现好理解了许多,区别也很明显,call是为obj.fn()执行后,返回的匿名函数,进行了显示绑定,所以输出结果为fn: obj,之后又会输出inner-a: obj2

4.new操作符进行绑定

在普通函数被当成构造函数,执行new操作生成对象时,函数中的this会被绑定为新创建的对象。

题目一:

function Person (age) {
  this.age = age
  this.fn1 = function () {
    console.log(this.age)
  }
  this.fn2 = function () {
    return function () {
      console.log(this.age)
    }
  }
}
var person1 = new Person(20)
person1.fn1()
person1.fn2()()
复制代码

我们可以分析到person1对象创建后person1.fn1()打印出来的就是构造函数中传入的20,所以会先输出20;而person1.fn2()返回的是一个匿名函数,之后匿名函数又被调用,调用者是window,而window.age没有被定义,所以会输出undefined

其实和用字面量创建对象十分类似,使用new关键字创建对象的this指向几乎是没有区别,可以靠同一套逻辑来进行判断。

5.箭头函数绑定

之前我们说过,哪个对象最后调用函数,函数中的this就指向那个对象(箭头函数除外),为啥箭头函数除外呢?因为箭头函数中的this,是要根据作用域链进行查找,来决定的。

题目一:

var obj = {
  name: 'obj',
  fn1: () => {
    console.log(this.name)
  },
  fn2: function () {
    console.log(this.name)
    return () => {
      console.log(this.name)
    }
  }
}
var name = 'window'
obj.fn1()
obj.fn2()()
复制代码

先来分析obj.fn1(),因为fn1是一个箭头函数,所以在调用的时候,其外部作用域是window,所以先输出window;再看obj.fn2()(),因为obj.fn2是个普通函数,所以执行时,先打印的this.nameobj,之后返回了一个匿名箭头函数,它的this指向是由外部作用域确定的,所以它内部的this其实用的就是fn2中的this,所以打印的this.name依旧是obj,最终输出为:

'window'
'obj'
'obj'
复制代码

题目二:

如果将普通函数和箭头函数嵌套,那么this该如何判断呢?根据排列组合我们可以得到4种情况:普通套普通;普通套箭头;箭头套普通;箭头套箭头,你别说,写项目的时候,还真会有人这样写,然后就会遇到很奇怪的bug。

var name = 'window'
var obj1 = {
  name: 'obj1',
  fn: function () {
    console.log(this.name)
    return function () {
      console.log(this.name)
    }
  }
}
var obj2 = {
  name: 'obj2',
  fn: function () {
    console.log(this.name)
    return () => {
      console.log(this.name)
    }
  }
}
var obj3 = {
  name: 'obj3',
  fn: () => {
    console.log(this.name)
    return function () {
      console.log(this.name)
    }
  }
}
var obj4 = {
  name: 'obj4',
  fn: () => {
    console.log(this.name)
    return () => {
      console.log(this.name)
    }
  }
}

obj1.fn()()
obj2.fn()()
obj3.fn()()
obj4.fn()()
复制代码

我们一条一条来分析:

  • obj1.fn()在执行后,因为fn是一个普通函数,所以内部的this指向obj,首先输出obj1,之后返回了一个匿名的普通函数,和前文说过的一样,是window来调用的,所以又会输出window,我们已经很熟悉了;
  • obj2.fn()在执行后,结果是obj2,因为返回的匿名函数是箭头函数,所以其内部的this使用的就是fn中的this,输出obj2
  • obj3.fn()是一个箭头函数,由外部作用域决定this取值,所以先输出window,返回的匿名普通函数,调用者是window,所以输出window
  • obj4.fn()()同理,是两个箭头函数,所以输出结果为两个window

我们还可以得出一个结论,箭头函数中的this由外层作用域决定,并且指向函数定义时的this,而并非调用时。同时,我们虽然没法用call apply bind来改变箭头函数中的this指向,但是我们可以通过改变箭头函数外层作用域的this指向,间接的改变箭头函数中this的指向。

关于this的内容,我们暂时告一段落,接下来,我们写一下之前使用过new call apply bind的原理,面试中的高频考点哦~

new的实现原理

//写一个模拟new的函数
function mockNew() {
  //获取第一个参数即构造函数,因为shift的返回值就是第一个参数,同时arguments数组中第一个参数被移除掉了
  let Constructor = [].shift.call(arguments);
  //创建一个新对象
  let obj = {};
  //新对象的__proto__指向构造函数的prototype,从而obj能方位原型上的属性
  obj.__proto__ = Constructor.prototype;
  // 上边两个步骤可以合并为let obj = Object.create(Construcrot.prototype),知识为了看的更清楚才分开写了
  //执行构造函数,改变this指向,使得obj能访问到构造函数中的属性
  let result = Constructor.apply(obj, arguments);
  // 加上这一步的作用就是如果构造函数有返回值(一般我们不会这样去做),那么就返回,否则,默认返回obj
  return result instanceof Object ? result : obj;
}

// 试验一下
function Animal(type) {
  this.type = type;
}
Animal.prototype.say = function() {
  console.log('say');
}
let o = mockNew(Animal, '哺乳类');

o.say();
console.log(o.type);
复制代码

顺便提一句,既然我们用到了instanceof,那我们写一下其原理是怎么实现的吧~其实就是根据__proto__属性,在原型链上不断查找,instanceof左边是实例对象,右边是构造函数或类:

function instanceOf (A, B) {
  B = B.prototype
  A = A.__proto__
  while (true) {
    if (A === null) {
      return false
    }
    if (A === B) {
      return true
    }
    A = A.__proto__
  }
}
// 尝试一下
class A {

}
let a = new A()
let res = instanceOf(a, A)
console.log(res)

复制代码

call实现原理

Function.prototype.call = function (context, ...args) {
  // 如果context为真值,那么将其包装成一个对象
  context = context ? Object(context) : window
  // 创建一个独一无二的fn名
  let fn = Symbol()
  // 将this赋值给context.fn属性,这里的this就是指调用call的那个函数
  context[fn] = this
  // 这样,在调用这个函数的时候,因为被放置在了context里边,所以this就会指向context
  context[fn](...args)
  delete context[fn]
  return result
}
复制代码

apply实现原理

applycall是类似的,只不过传参不一样,能看懂call的话,那么apply也不在话下!

Function.prototype.apply = function(context, arr) {
  context = context ? Object(context) : window;
  let fn = Symbol();
  context[fn] = this;

  let result = arr ? context[fn](...arr) : context[fn]();
  delete context[fn];
  return result;
};
复制代码

bind实现原理

bind在内部使用了apply,返回一个新的函数,所以代码如下:

Function.prototype.bind = function (context, ...args) {
  return (...argument) => {
    return this.apply(context, [...args, ...argument])
  }
}
// 尝试一下
let obj = {
  name: 'jw'
}
function fn (a, b) {
  console.log(this.name, a + b)
}
let bindFn = fn.bind(obj, 9)
bindFn(3)
复制代码

结尾

关于this的问题,我们看完这篇文章,大致就能比较清楚的判断了,如果在项目中,因为this指向出现一些问题,也能及时的排查出来。下次看到了绕来绕去代码,this乱指,如果是在面试中,不妨耐着性子一点点梳理,如果是你同事写出来的代码,一巴掌直接呼过去了就。

分类:
前端
收藏成功!
已添加到「」, 点击更改