# 做完这48道题彻底弄懂JS继承|博客系列

> 本文通过48道精选题目，系统讲解JavaScript继承的8种方式，包括原型链继承、构造函数继承、组合继承等，帮助读者全面理解JS对象继承机制及其应用场景，适合前端开发者查阅和学习。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/10-%E5%81%9A%E5%AE%8C%E8%BF%9948%E9%81%93%E9%A2%98%E5%BD%BB%E5%BA%95%E5%BC%84%E6%87%82JS%E7%BB%A7%E6%89%BF
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## JavaScript对象封装、多态、继承

### 继承

**继承就是子类可以使用父类的所有功能，并且对这些功能进行扩展。**

比如我有个构造函数`A`，然后又有个构造函数`B`，但是`B`想要使用`A`里的一些属性和方法，一种办法就是让我们自身化身为`CV侠`，复制粘贴一波。还有一种就是利用继承，我让`B`直接继承了`A`里的功能，这样我就能用它了。

今天要介绍的八种继承方式在目录中都已经列举出来了。

不着急，从浅到深咱一个个来看。

### 1. 原型链继承

将子类的原型对象指向父类的实例

#### 1.1 题目一

（理解原型链继承的概念）

```javascript
function Parent () {
  this.name = 'Parent'
  this.sex = 'boy'
}
Parent.prototype.getName = function () {
  console.log(this.name)
}
function Child () {
  this.name = 'child'
}
Child.prototype = new Parent()

var child1 = new Child()
child1.getName()
console.log(child1)
```

好了，快告诉我答案吧，会打印出什么 🤔️ ？

```
'child'
Child {name: "child"}
```

这...这很好理解呀

- `child1`是通过子类构造函数`Child`生成的对象，那我就有属性`name`，并且属性值也是自己的`child`
- 然后子类构造函数`Child`它的原型被指向了父类构造函数`Parent`创建出来的`"无名实例"`
- 这样的话，我`child1`就可以使用你这个`"无名实例"`里的所有属性和方法了呀，因此`child1.getName()`有效。并且打印出`child`。
- 另外由于`sex、getName`都是`Child`原型对象上的属性，所以并不会表现在`child1`上。

![](https://s.poetries.top/gitee/2020/09/181.png)

所以现在你知道了吧，这种方式就叫做**原型链继承**。

**将子类的原型对象指向父类的实例。**

我们来写个伪代码，方便记忆：

```javascript
Child.prototype = new Parent()
```
当然，更加严谨一点的做法其实还有一步：`Child.prototype.constructor = Child`，不过这边先卖个关子，到题目`4.2`中我们再来详细说它。

#### 1.2 题目二

不知道你们在看到**原型链继承**这个词语的时候，第一时间想到的是什么？

有没有和我一样，想到的是把子类的原型对象指向父类的原型对象的😂：

```javascript
Child.prototype = Parent.prototype
```

和我一样的举个手给我看下🙋‍♂️，😂

之后我就为我xx似的想法感到惭愧...

如果我只能拿到父类原型链上的属性和方法那也太废了吧，我可不止这样，我还想拿到父类构造函数上的属性。

所以这道题：

```javascript
function Parent () {
  this.name = 'Parent'
  this.sex = 'boy'
}
Parent.prototype.getSex = function () {
  console.log(this.sex)
}
function Child () {
  this.name = 'child'
}
Child.prototype = Parent.prototype

var child1 = new Child()
child1.getSex()
console.log(child1)
```

结果为：

```javascript
undefined
Child {name: "child"}
```

你可以结合上面👆的那张图，自个儿脑补一下，`child1`它的原型链现在长啥样了。

解析：

- `child1`上能使用的属性和方法只有`name、getSex`，所以`getSex`打印出的会是`undefined`
- 打印出的`child1`只有`name`属性，`getSex`为原型上的方法所以并不会表现出来。

这道题是个错误的做法啊 😂

我只是为了说明一下，为什么**原型链继承**是要用`Child.prototype = new Parent()`这种方式。

#### 1.3 题目三

（理解原型链继承的优点和缺点）

这道题的结果大家能想到吗？

请注意对象是地址引用的哦。

```javascript
function Parent (name) {
  this.name = name
  this.sex = 'boy'
  this.colors = ['white', 'black']
}
function Child () {
  this.feature = ['cute']
}
var parent = new Parent('parent')
Child.prototype = parent

var child1 = new Child('child1')
child1.sex = 'girl'
child1.colors.push('yellow')
child1.feature.push('sunshine')

var child2 = new Child('child2')

console.log(child1)
console.log(child2)

console.log(child1.name)
console.log(child2.colors)

console.log(parent)
```

答案：

```javascript
Child{ feature: ['cute', 'sunshine'], sex: 'girl' }
Child{ feature: ['cute'] }

'parent'
['white', 'black', 'yellow']

Parent {name: "parent", sex: 'boy', colors: ['white', 'black', 'yellow'] }
```

解析：

- `child1`在创建完之后，就设置了`sex`，并且给`colors`和`feature`都`push`了新的内容。
- `child1.sex = 'girl'`这段代码相当于是给`child1`这个实例对象新增了一个`sex`属性。相当于是：原本我是没有`sex`这个属性的，我想要获取就得拿原型对象`parent`上的`sex`，但是现在你加了一句`child1.sex`就等于是我自己也有了这个属性了，就不需要你原型上的了，所以并不会影响到原型对象`parent`上😊。
- 但是`child1.colors`这里，注意它的操作，它是直接使用了`.push()`的，也就是说我得先找到`colors`这个属性，发现实例对象`parent`上有，然后就拿来用了，之后执行`push`操作，所以这时候改变的是原型对象`parent`上的属性，会影响到后续所有的实例对象。(这里你会有疑问了，凭什么`sex`就是在实例对象`child`上新增，而我`colors`不行，那是因为操作的方式不同，`sex`那里是我不管你有没有，反正我就直接用`=`来覆盖你了，可是`push`它的前提是我得先有`colors`且类型是数组才行，不然你换成没有的属性，比如一个名为`clothes`的属性，`child1.clothes.push('jacket')`它直接就报错了，如果你使用的是`child1.colors = ['yellow']`这样才不会影响`parent`)
- 而`feature`它是属于`child1`实例自身的属性，它添加还是减少都不会影响到其他实例。
- 因此`child1`打印出了`feature`和`sex`两个属性。(`name`和`colors`属于原型对象上的属性并不会被表现出来)
- `child2`没有做任何操作，所以它打印出的还是它自身的一个`feature`属性😁。
- `child1.name`是原型对象`parent`上的`name`，也就是`'parent'`，虽然我们在`new Child`的时候传递了`'child1'`，但它显然是无效的，因为接收`name`属性的是构造函数`Parent`，而不是`Child`。
- `child2.colors`由于用的也是原型对象`parent`上的`colors`，又由于之前被`child1`给改变了，所以打印出来的会是`['white', 'black', 'yellow']`
- 将最后的原型对象`parent`打印出来，`name`和`sex`没变，`colors`却变了。

分析的真漂亮，漂亮的这么一大串我都不想看了...

咳咳，不过你要是能静下来认真的读一读的话就会觉得真没啥东西，甚至不需要记什么，我就理解了。

#### 总结-原型链继承

现在我们就可以得出**原型链继承**它的优点和缺点了

**优点：**

- 继承了父类的模板，又继承了父类的原型对象

**缺点：**

- 如果要给子类的原型上新增属性和方法，就必须放在`Child.prototype = new Parent()`这样的语句后面
- 无法实现多继承(因为已经指定了原型对象了)
- 来自原型对象的所有属性都被共享了，这样如果不小心修改了原型对象中的引用类型属性，那么所有子类创建的实例对象都会受到影响(这点从修改`child1.colors`可以看出来)
- 创建子类时，无法向父类构造函数传参数(这点从`child1.name`可以看出来)

这...这看到没，压根就不需要记，想想出的这道变态的题面试的时候被问到脱口就来了。

### 2. instanceof

#### 2.1 题目一

这道题主要是想介绍一个重要的运算符: **instanceof**

先看看官方的简介：

**`instanceof`** **运算符**用于检测构造函数的 `prototype` 属性是否出现在某个实例对象的原型链上。

再来看看通俗点的简介：

`a instanceof B`

`实例对象a instanceof 构造函数B`

检测`a`的原型链`(__proto__)`上是否有`B.prototype`，有则返回`true`，否则返回`false`。

上题吧：

```javascript
function Parent () {
  this.name = 'parent'
}
function Child () {
  this.sex = 'boy'
}
Child.prototype = new Parent()
var child1 = new Child()

console.log(child1 instanceof Child)
console.log(child1 instanceof Parent)
console.log(child1 instanceof Object)
```

结果为：

```
true
true
true
```

这里就利用了前面👆提到的原型链继承，而且三个构造函数的原型对象都存在于`child1`的原型链上。

也就是说，左边的`child1`它会向它的原型链中不停的查找，看有没有右边那个构造函数的原型对象。

例如`child1 instanceof Child`的查找顺序：

```javascript
child1 -> child1.__proto__ -> Child.prototype
```

`child1 instanceof Parent`的查找顺序：

```javascript
child1 -> child1.__proto__ -> Child.prototype
-> Child.prototype.__proto__ -> Parent.prototype
```

还不理解？

没关系，我还有大招：

我在上面👆原型链继承的思维导图上加了三个查找路线。

被⭕️标记的`1、2、3`分别代表的是`Child、Parent、Object`的原型对象。

![](https://s.poetries.top/gitee/2020/09/182.png)

好滴，一张图简洁明了。以后再碰到`instanceof`这种东西，按照我图上的查找路线来查找就可以了 😁 ～

#### 2.2 题目二

（了解`isPrototypeOf()`的使用）

既然说到了`instanceof`，那么就不得不提一下`isPrototypeOf`这个方法了。

它属于`Object.prototype`上的方法，这点你可以将`Object.prototype`打印在控制台中看看。

`isPrototypeOf()`的用法和`instanceof`相反。

它是用来判断指定对象`object1`是否存在于另一个对象`object2`的原型链中，是则返回`true`，否则返回`false`。 

例如还是上面👆这道题，我们将要打印的内容改一下：

```javascript
function Parent () {
  this.name = 'parent'
}
function Child () {
  this.sex = 'boy'
}
Child.prototype = new Parent()
var child1 = new Child()

console.log(Child.prototype.isPrototypeOf(child1))
console.log(Parent.prototype.isPrototypeOf(child1))
console.log(Object.prototype.isPrototypeOf(child1))
```

这里输出的依然是三个`true`：

```javascript
true
true
true
```

判断的方式只要把**原型链继承instanceof查找思维导图**这张图反过来查找即可。

### 3. 构造继承

了解了最简单的**原型链继承**，再让我们来看看**构造继承**呀，也叫做**构造函数继承**。

在子类构造函数内部使用`call或apply`来调用父类构造函数

为了方便你查看，我们先来复习一波`.call`和`apply`方法。

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

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

#### 3.1 题目一

（构造继承的基本原理）

所以来看看这道题？

```javascript
function Parent (name) {
  this.name = name
}
function Child () {
  this.sex = 'boy'
  Parent.call(this, 'child')
}
var child1 = new Child()
console.log(child1)
```

`child1`中会有哪些属性呢？

首先`sex`我们知道肯定会有的，毕竟它就是构造函数`Child`里的。

其次，我们使用了`Parent.call(this, 'child')`，`.call`函数刚刚已经说过了，它是会立即执行的，而这里又用了`.call`来改变`Parent`构造函数内的指向，所以我们是不是可以将它转化为伪代码：

```javascript
function Child () {
	this.sex = 'boy'
	// 伪代码
	this.name = 'child'
}
```

你就理解为相当于是直接执行了`Parent`里的代码。使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类。

所以构造继承的原理就是：

**在子类构造函数内部使用`call或apply`来调用父类构造函数**

同样的，来写下伪代码：

```javascript
function Child () {
    Parent.call(this, ...arguments)
}
```

（`arguments`表示的是你可以往里面传递参数，当然这只是伪代码）

#### 3.2 题目二

如果你觉得上面👆这道题还不具有说明性，我们来看看这里。

现在我在子类和父类中都加上`name`这个属性，你觉得生出来的会是**好孩子**还是**坏孩子**呢？

```javascript
function Parent (name) {
  this.name = name
}
function Child () {
  this.sex = 'boy'
  Parent.call(this, 'good boy')
  this.name = 'bad boy'
}
var child1 = new Child()
console.log(child1)
```

其实是好是坏很好区分，只要想想`3.1`里，把`Parent.call(this, 'good boy')`换成伪代码就知道了。

换成了伪代码之后，等于是重复定义了两个相同名称的属性，当然是后面的覆盖前面的啦。

所以结果为：

```javascript
Child {sex: "boy", name: "bad boy"}
```

这道题如果换一下位置：

```javascript
function Child () {
  this.sex = 'boy'
  this.name = 'bad boy'
  Parent.call(this, 'good boy')
}
```

这时候就是好孩子了。

#### 3.3 题目三

（构造继承的优点）

解决了**原型链继承**中子类共享父类引用对象的问题

刚刚的题目都是一些基本数据类型，让我来加上引用类型看看

```javascript
function Parent (name, sex) {
  this.name = name
  this.sex = sex
  this.colors = ['white', 'black']
}
function Child (name, sex) {
  Parent.call(this, name, sex)
}
var child1 = new Child('child1', 'boy')
child1.colors.push('yellow')

var child2 = new Child('child2', 'girl')
console.log(child1)
console.log(child2)
```

这道题看着和`1.3`好像啊，没错，在父类构造函数中有一个叫`colors`的数组，它是地址引用的。

在**原型链继承**中我们知道，子类构造函数创建的实例是会查找到原型链上的`colors`的，而且改动它会影响到其它的实例，这是**原型链继承**的一大缺点。

而现在呢？你看看使用了**构造继承**，结果为：

```javascript
Child{ name: 'child1', sex: 'boy', colors: ['white', 'black', 'yellow'] }
Child{ name: 'child2', sex: 'girl', colors: ['white', 'black'] }
```

我们发现修改`child1.colors`并不会影响到其它的实例(`child2`)耶。

这里的原因其实我们前面也说了：

使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类。

所以现在`child1`和`child2`现在分别有它们各自的`colors`了，就不共享了。

而且这种拷贝属于深拷贝，验证的方式是你可以把`colors`数组中的每一项改为一个对象，然后修改它看看。

```javascript
function Parent () {
	//...
	this.colors = [{ title: 'white' }, { title: 'black' }]
}
```

因此我们可以得出**构造继承**的优点：

- 解决了原型链继承中子类实例共享父类引用对象的问题，实现多继承，创建子类实例时，可以向父类传递参数

#### 3.4 题目四

（构造继承的缺点一）

在了解继承的时候，我们总是会想到原型链上的属性和方法能不能被继承到。

采用了这种**构造继承**的方式，能不能继承父类原型链上的属性呢？

来看下面👇这道题目

```javascript
function Parent (name) {
  this.name = name
}
Parent.prototype.getName = function () {
  console.log(this.name)
}
function Child () {
  this.sex = 'boy'
  Parent.call(this, 'good boy')
}
Child.prototype.getSex = function () {
  console.log(this.sex)
}
var child1 = new Child()
console.log(child1)
child1.getSex()
child1.getName()
```

我给子类和父类的原型对象上都分别加了一个方法，然后调用它们。

结果竟然是：

```javascript
Child {sex: "boy", name: "good boy"}
'boy'
Uncaught TypeError: child1.getName is not a function
```

- `sex、name`属性都有这个我们都可以理解
- `getSex`属于`Child`构造函数原型对象上的方法，我们肯定是能用它的，这个也好理解
- 那`getName`呢？它属于父类构造函数原型对象上的方法，报错了？怎么滴？我子类不配使用你啊？

你确实是不配使用我。

你使用`Parent.call(this, 'good boy')`只不过是让你复制了一下我构造函数里的属性和方法，可没说能让你复制我原型对象的啊～年轻人，不要这么贪嘛。

#### 3.5 题目五

（构造继承的缺点二）

它的第二个缺点是：实例并不是父类的实例，只是子类的实例。

停一下，让我们先来思考一下这句话的意思，然后想想怎样来验证它呢 🤔️ ？

一分钟...二分钟...三分钟...

啊，我知道了，刚刚不是才学的一个叫`instanceof`的运算符吗？它就能检测某个实例的原型链上能不能找到构造函数的原型对象。

换句话说就能检测某个对象是不是某个构造函数的实例啦。

所以让我们来看看：

```javascript
function Parent (name) {
  this.name = name
}
function Child () {
  this.sex = 'boy'
  Parent.call(this, 'child')
}
var child1 = new Child()

console.log(child1)
console.log(child1 instanceof Child)
console.log(child1 instanceof Parent)
console.log(child1 instanceof Object)
```

结果为：

```javascript
Child {sex: "boy", name: "child"}
true
false
true
```

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/10-%E5%81%9A%E5%AE%8C%E8%BF%9948%E9%81%93%E9%A2%98%E5%BD%BB%E5%BA%95%E5%BC%84%E6%87%82JS%E7%BB%A7%E6%89%BF
