# 再来40道this面试题酸爽继续|博客系列

> 本文系统梳理了JavaScript中this的五种绑定方式，通过40道典型面试题深入讲解this的指向原理、常见陷阱及实际应用场景，帮助读者全面掌握this相关知识点，提升面试与实战能力。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/3-%E5%86%8D%E6%9D%A540%E9%81%93this%E9%9D%A2%E8%AF%95%E9%A2%98%E9%85%B8%E7%88%BD%E7%BB%A7%E7%BB%AD
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## 前期准备

在正式阅读之前，你需要知道`this`的5种绑定方式：

- 默认绑定(非严格模式下this指向全局对象, 严格模式下`this`会绑定到`undefined`)
- 隐式绑定(当函数引用有**上下文对象**时, 如 `obj.foo()`的调用方式, `foo`内的`this`指向`obj`)
- 显示绑定(通过`call()`或者`apply()`方法直接指定`this`的绑定对象, 如`foo.call(obj)`)
- new绑定
- 箭头函数绑定(`this`的指向由外层作用域决定的)

### 1. 默认绑定

先介绍一种最简单的绑定方式吧：**默认绑定**。

也就是我们常说的：在非严格模式下`this`指向的是全局对象`window`，而在严格模式下会绑定到`undefined`。

#### 1.1 题目一

老规矩，来看个最基本的案例：

```javascript
var a = 10;
function foo () {
  console.log(this.a)
}
foo();
```

我们知道在使用`var`创建变量的时候(不在函数里)，会把创建的变量绑定到`window`上，所以此时`a`是`window`下的属性。

而函数`foo`也是`window`下的属性。

因此上面的代码其实就相当于是这样:

```javascript
window.a = 10;
function foo() {
  console.log(this.a)
}
window.foo();
```

在这里，调用`foo()`函数的是`window`对象，且又是在非严格模式下，所以`foo()`中`this`的指向是`window`对象，因此`this.a`会输出`10`。

答案：

```
10
```

#### 1.2 题目二

改造下题目一，看看在严格模式下。

(想要开启严格模式，只要在需要开启的地方写上`"use strict"`)

```javascript
"use strict";
var a = 10;
function foo () {
  console.log('this1', this)
  console.log(window.a)
  console.log(this.a)
}
console.log(window.foo)
console.log('this2', this)
foo();
```

需要注意的点：

- 开启了严格模式，只是说使得函数内的`this`指向`undefined`，它并不会改变全局中`this`的指向。因此`this1`中打印的是`undefined`，而`this2`还是`window`对象。

- 另外，它也不会阻止`a`被绑定到`window`对象上。

所以最后的执行结果：

```
f foo() {...}
'this2' Window{...}
'this1' undefined
10
Uncaught TypeError: Cannot read property 'a' of undefined
```

#### 1.3 题目三

```javascript
let a = 10
const b = 20

function foo () {
  console.log(this.a)
  console.log(this.b)
}
foo();
console.log(window.a)
```

如果把`var`改成了`let 或者 const`，变量是不会被绑定到`window`上的，所以此时会打印出三个`undefined`。

答案：

```
undefined
undefined
undefined
```

#### 1.4 题目四

```javascript
var a = 1
function foo () {
  var a = 2
  console.log(this)
  console.log(this.a)
}

foo()
```

这里我们很容易就知道，`foo()`函数内的`this`指向的是`window`，因为是`window`调用的`foo`。

但是打印出的`this.a`呢？注意，是`this.a`，不是`a`，因此是`window`下的`a`。

并且由于函数作用域的原因我们知道`window`下的`a`还是`1`。

因此答案为：

```
Window{...}
1
```

#### 1.5 题目五

把题目`1.4`改造一下 😁。

```javascript
var a = 1
function foo () {
  var a = 2
  function inner () { 
    console.log(this.a)
  }
  inner()
}

foo()
```

其实这里和`1.4`很像，不过一看到函数内的函数，就很容易让人联想到闭包 😂，然后... 然后就脱口而出，答案是`2`啊，这还不简单。

小伙伴们，审题可得仔细啊，这里问你的是`this.a`，而在`inner`中，`this`指向的还是`window`。

答案：

```
1
```

(我知道有的小伙伴不满这种题目，这吖的不就是和人玩文字游戏吗？有什么技术含量，但是现实就是这样，很多面试官会喜欢问这种细节题来考察你细心不细心。在没能力改变这种情况的前提下，你只能试着接受它...)

### 2. 隐式绑定

OK👌，介绍完了默认绑定之后，让我们来看看第二种**隐式绑定**。

其实大佬  [sunshine小小倩](https://juejin.im/user/584d7a3e2f301e00572fb7fc) 教了我们一个简单的规则，**this 永远指向最后调用它的那个对象**。

谁最后调用的函数，函数内的`this`指向的就是谁(不考虑箭头函数)。

(了解上下文对象的小伙伴应该都知道，这与上下文对象以及作用域有关，想要了解的小伙伴可以看我的这篇文章[《JavaScript进阶-执行上下文栈和变量对象(一周一更)》](https://juejin.im/post/5dc7dbbc6fb9a04aa0014e3f)

下面你可以用这个规则来做题啦 😁。

#### 2.1 题目一

```javascript
function foo () {
  console.log(this.a)
}
var obj = { a: 1, foo }
var a = 2
obj.foo()
```

(`var obj = { foo }`就相当于是`var obj = { foo: foo }`，这个大家应该都知道吧)

在这道题中，函数`foo()`虽然是定义在`window`下，但是我在`obj`对象中引用了它，并将它重新赋值到`obj.foo`上。

且调用它的是`obj`对象，因此打印出来的`this.a`应该是`obj`中的`a`。

换个角度想，上面👆这段代码是不是就相当于是这样：

```javascript
var obj = {
  a: 1,
  foo: function () {
    console.log(this.a)
  }
}
var a = 2
obj.foo()
```

在这里`foo`函数内的`this`指向的就是`obj`，和题目效果一样。

答案都是：

```
1
```

有小伙伴就会有有疑问了，`obj.foo()`不就相当于是`window.obj.foo()`吗？

那`foo()`内的`this`到底是算`window`呢，还是`obj`呢？

请注意我前面说的，是最后调用函数的对象，显然，`obj`要比`window`更后面一点。

### 3. 隐式绑定的隐式丢失问题

隐式绑定的基本概念大家应该都清楚了，不过其实有一个关于隐式绑定的常用考点，那就是**隐式丢失问题**。

> 隐式丢失其实就是被隐式绑定的函数在特定的情况下会丢失绑定对象。

有两种情况容易发生隐式丢失问题：

- 使用另一个变量来给函数取别名
- 将函数作为参数传递时会被隐式赋值，回调函数丢失this绑定

我们一种一种来看哈。

#### 3.1 题目一

使用另一个变量来给函数取别名会发生隐式丢失。

```javascript
function foo () {
  console.log(this.a)
};
var obj = { a: 1, foo };
var a = 2;
var foo2 = obj.foo;

obj.foo();
foo2();
```

执行这段代码会打印出啥呢 🤔️？

在这里我们已经知道了，`obj.foo()`中`this`的指向是为`obj`的(可以看第二部分`隐式绑定`)，所以`obj.foo()`执行的时候，打印出来的是`obj`对象中的`a`，也就是`1`。

但是`foo2`它不也是`obj.foo`吗？我只不过是用了一个变量`foo2`来盛放了它而已。所以你是不是认为它打印的也是`1`呢？

额 😅，其实这里不是的，它打印出的是`window`下的`a`。

答案：

```
1
2
```

这是因为虽然`foo2`指向的是`obj.foo`函数，不过调用它的却是`window`对象，所以它里面`this`的指向是为`window`。

其实也就相当于是`window.foo2()`，如果你不相信的话，可以看下面一题👇。

#### 3.2 题目二

让我们在一个新的变量`obj2`中也定义一个`foo2`看看：

```javascript
function foo () {
  console.log(this.a)
};
var obj = { a: 1, foo };
var a = 2;
var foo2 = obj.foo;
var obj2 = { a: 3, foo2: obj.foo }

obj.foo();
foo2();
obj2.foo2();
```

这三种不同的`foo()`打印出来的分别是什么呢？

答案：

```
1
2
3
```

- `obj.foo()`中的`this`指向调用者`obj`
- `foo2()`发生了隐式丢失，调用者是`window`，使得`foo()`中的`this`指向`window`
- `foo3()`发生了隐式丢失，调用者是`obj2`，使得`foo()`中的`this`指向`obj2`

#### 3.3 题目三

再就是如果你把一个函数当成参数传递时，也会被隐式赋值，发生意想不到的问题。

来看看这道题目：

```javascript
function foo () {
  console.log(this.a)
}
function doFoo (fn) {
  console.log(this)
  fn()
}
var obj = { a: 1, foo }
var a = 2
doFoo(obj.foo)
```

这里我们将`obj.foo`当成参数传递到`doFoo`函数中，在传递的过程中，`obj.foo()`函数内的`this`发生了改变，指向了`window`。

因此结果为：

```
Window{...}
2
```

注意，我这里说的是`obj.foo()`函数，而不是说`doFoo()`。`doFoo()`函数内的`this`本来就是指向`window`的，因为这里是`window`调用的它。

但是你不要以为是`doFoo()`函数内的`this`影响了`obj.foo()`，不信你看下一题。

#### 3.4 题目四

现在我们不用`window`调用`doFoo`，而是放在对象`obj2`里，用`obj2`调用：

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

obj2.doFoo(obj.foo)
```

现在调用`obj2.doFoo()`函数，里面的`this`指向的应该是`obj2`，因为是`obj2`调用的它。

但是`obj.foo()`打印出来的`a`依然是`2`，也就是`window`下的。

执行结果为：

```
{ a:3, doFoo: f }
2
```

**所以说，如果你把一个函数当成参数传递到另一个函数的时候，也会发生隐式丢失的问题，且与包裹着它的函数的this指向无关。在非严格模式下，会把该函数的this绑定到window上，严格模式下绑定到undefined。**

一样的代码，试试严格模式下：

```javascript
"use strict"
function foo () {
  console.log(this.a)
}
function doFoo (fn) {
  console.log(this)
  fn()
}
var obj = { a: 1, foo }
var a = 2
var obj2 = { a: 3, doFoo }

obj2.doFoo(obj.foo)
```

执行结果：

```
{ a:3, doFoo: f }
Uncaught TypeError: Cannot read property 'a' of undefined
```

### 4. 显式绑定

功能如其名，就是强行使用某些方法，改变函数内`this`的指向。

通过`call()、apply()`或者`bind()`方法直接指定`this`的绑定对象, 如`foo.call(obj)`。

这里有几个知识点需要注意：

- 使用`.call()`或者`.apply()`的函数是会直接执行的
- `bind()`是创建一个新的函数，需要手动调用才会执行
- `.call()`和`.apply()`用法基本类似，不过`call`接收若干个参数，而`apply`接收的是一个数组

(其实这应该是经常听到的知识点了吧 😅)

来看看题目一。

#### 4.1 题目一

```javascript
function foo () {
  console.log(this.a)
}
var obj = { a: 1 }
var a = 2

foo()
foo.call(obj)
foo.apply(obj)
foo.bind(obj)
```

第一个`foo()` 都很好理解，这不就是默认绑定吗？😁

而第二个和第三个`foo`都使用了`call`或`apply`来改变`this`的指向，并且是立即执行的。

第四个`foo`，仅仅是使用`bind`创建了一个新的函数，且这个新函数也没用别的变量接收并调用，因此并不会执行。

答案：

```
2
1
1
```

这里想要提一嘴，如果`call、apply、bind`接收到的第一个参数是空或者`null、undefined`的话，则会忽略这个参数。

例如🌰：

```javascript
function foo () {
  console.log(this.a)
}
var a = 2
foo.call()
foo.call(null)
foo.call(undefined)
```

输出的是：

```
2
2
2
```

#### 4.2 题目二

了解了显式绑定的基本使用之后，让我们来看看它的妙用。

首先，是这个例子🌰：

```javascript
var obj1 = {
  a: 1
}
var obj2 = {
  a: 2,
  foo1: function () {
    console.log(this.a)
  },
  foo2: function () {
    setTimeout(function () {
      console.log(this)
      console.log(this.a)
    }, 0)
  }
}
var a = 3

obj2.foo1()
obj2.foo2()
```

对于`obj2.foo1()`，我们很清楚，它就是打印出`2`。

但是对于`obj2.foo2`呢？在这个函数里，设置了一个定时器，并要求我们打印出`this`和`this.a`。

想想我前面说过的话，谁调用的函数，函数内的`this`指向的就是谁。

而对于匿名函数，它里面的`this`在非严格模式下始终指向的都是`window`。

所以最终的结果是：

```
2
Window{...}
3
```

#### 4.3 题目三

面对上面👆这种情况我们就可以使用`call、apply` 或者`bind`来改变函数中`this`的指向，使它绑定到`obj1`上，从而打印出`1`。

```javascript
var obj1 = {
  a: 1
}
var obj2 = {
  a: 2,
  foo1: function () {
    console.log(this.a)
  },
  foo2: function () {
    setTimeout(function () {
      console.log(this)
      console.log(this.a)
    }.call(obj1), 0)
  }
}
var a = 3
obj2.foo1()
obj2.foo2()
```

现在的执行结果就是：

```
2
{ a: 1 }
1
```

但是看看我这里的写法，我是将`.call`运用到`setTimeout`里的回调函数上，并不是运用到`obj2.foo2()`上。

所以有小伙伴就会问了，我下面的这种写法不可以吗？

```javascript
obj2.foo2.call(obj1)
```

**注意⚠️**：如果是这种写法的话，我改变的就是`foo2`函数内的`this`的指向了，但是我们知道，`foo2`函数内`this`的指向和`setTimeout`里函数的`this`是没有关系的，因为调用定时器的始终是`window`。

并且这里使用`.bind()`也是可以的，因为定时器里的函数在时间到了之后本就是会自动执行的。

#### 4.4 题目四

OK👌，我们不用定时器，把它干掉，换成一个函数：

```javascript
var obj1 = {
  a: 1
}
var obj2 = {
  a: 2,
  foo1: function () {
    console.log(this.a)
  },
  foo2: function () {
    function inner () {
      console.log(this)
      console.log(this.a)
    }
    inner()
  }
}
var a = 3
obj2.foo1()
obj2.foo2()
```

其实这里有点像题目`1.5`有木有，都是函数内包裹着函数。

调用`inner`函数的依然是`window`，所以结果为：

```
2
Window{...}
3
```

如果给`inner()`函数显式绑定的话：

```javascript
inner.call(obj1)
```

结果为

```
2
{ a: 1 }
1
```

#### 4.5 题目五

其实在实际面试中，面试官喜欢以这样的方式考你：

看看这道题，会输出什么呢 🤔️？

```javascript
function foo () {
  console.log(this.a)
}
var obj = { a: 1 }
var a = 2

foo()
foo.call(obj)
foo().call(obj)
```

也就是使用`.call()`方法位置的不同。

结果：

```
2
1
2
Uncaught TypeError: Cannot read property 'call' of undefined
```

- `foo()`会正常打印出`window`下的`a`，也就是`2`
- `foo.call(obj)`由于显式绑定了`this`，所以会打印出`obj`下的`a`，也就是`1`
- `foo().call(obj)`开始会执行`foo()`函数，打印出`2`，但是会对`foo()`函数的返回值执行`.call(obj)`操作，可是我们可以看到`foo()`函数的返回值是`undefined`，因此就会报错了。

所以我们可以看到`foo.call()`和`foo().call()`的区别了，一个是针对于函数，一个是针对于函数的返回值。

下面我会用更多的例题来帮助大家了解这类题目的解法。

#### 4.6 题目六

OK👌，既然刚刚`4.5`是因为函数没有返回值才报的错，那我现在给它加上返回值看看：

```javascript
function foo () {
  console.log(this.a)
  return function () {
    console.log(this.a)
  }
}
var obj = { a: 1 }
var a = 2

foo()
foo.call(obj)
foo().call(obj)
```

你能想到现在会输出什么吗？

答案是会输出`3`个数，还是`4`个数，亦或者`6`个数呢？

😁 嘻嘻，不逗你了，结果竟然是：

```
2
1
2
1
```

- 第一个数字`2`自然是`foo()`输出的，虽然`foo()`函数也返回了一个匿名函数，但是并没有调用它呀，只有写成`foo()()`，这样才算是调用匿名函数。
- 第二个数字`1`是`foo.call(obj)`输出的，由于`.call()`是紧跟着`foo`的，所以改变的是`foo()`内`this`的指向，并且`.call()`是会使函数立即执行的，因此打印出`1`，同理，它也没有调用返回的函数。
- 第三个数字`2`是`foo().call(obj)`先执行`foo()`时打印出来的，此时`foo()`内`this`还是指向`window`。
- 在执行完`foo()`之后，会返回一个匿名函数，并且后面使用了`.call(obj)`来改变这个匿名函数的`this`指向并调用了它，所以输出了`1`。

咦～好像从这道题开始，变得越来越有意思了哈 😁

#### 4.7 题目七

想想我们把`call`换成`bind`会怎么样呢？

先来回忆一下它们的区别：`call`是会直接执行函数的，`bind`是返回一个新函数，但不会执行。

```javascript
function foo () {
  console.log(this.a)
  return function () {
    console.log(this.a)
  }
}
var obj = { a: 1 }
var a = 2

foo()
foo.bind(obj)
foo().bind(obj)
```

结果自然就是：

```
2
2
```

- `foo()`会执行没错，打印出了`2`。
- 但是`foo.bind(obj)`却不会执行，它返回的是一个新函数。
- `foo().bind(obj)`只会执行前面的`foo()`函数，打印出`2`，`.bind(obj)`只是将`foo()`返回的匿名函数显式绑定`this`而已，并没有调用。

#### 4.8 题目八

说实话，做上面这类题目，会让我有一种疑惑。

这种函数内返回的函数，它的`this`会和它外层的函数有关吗？

也就是内层函数它的`this`到底是谁呢？

还是那句话，谁最后调用的它，`this`就指向谁。

```javascript
function foo () {
  console.log(this.a)
  return function () {
    console.log(this.a)
  }
}
var obj = { a: 1 }
var a = 2

foo.call(obj)()
```

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/3-%E5%86%8D%E6%9D%A540%E9%81%93this%E9%9D%A2%E8%AF%95%E9%A2%98%E9%85%B8%E7%88%BD%E7%BB%A7%E7%BB%AD
