正文 

当前位置： 首页 > java > java语法

重新理解js的6种继承方式

faithMeng      2022-02-11     460

关键词：

 

 

写在前面

一直不喜欢JS的OOP，在学习阶段好像也用不到，总觉得JS的OOP不伦不类的，可能是因为先接触了Java，所以对JS的OO部分有些抵触。

偏见归偏见，既然面试官问到了JS的OOP，那么说明这东西肯定是有用的，应该抛开偏见，认真地了解一下

约定

P.S.下面将展开一个有点长的故事，所以有必要提前约定共同语言：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * 约定
 */
function Fun(){
    // 私有属性
    var val = 1;        // 私有基本属性
    var arr = [1];      // 私有引用属性
    function fun(){}    // 私有函数（引用属性）
 
    // 实例属性
    this.val = 1;               // 实例基本属性
    this.arr = [1];             // 实例引用属性
    this.fun = function(){};    // 实例函数（引用属性）
}
 
// 原型属性
Fun.prototype.val = 1;              // 原型基本属性
Fun.prototype.arr = [1];            // 原型引用属性
Fun.prototype.fun = function(){};   // 原型函数（引用属性）

上面的约定应该是比较合理的，如果难以理解，可以查看黯羽轻扬：JS学习笔记2_面向对象，了解更多的基本常识

一.简单原型链

这是实现继承最简单的方式了，真的超简单，核心就一句话（在代码中用注释标明了）

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Super(){
    this.val = 1;
    this.arr = [1];
}
function Sub(){
    // ...
}
Sub.prototype = new Super();    // 核心
 
var sub1 = new Sub();
var sub2 = new Sub();
sub1.val = 2;
sub1.arr.push(2);
alert(sub1.val);    // 2
alert(sub2.val);    // 1
 
alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1, 2

2.核心

拿父类实例来充当子类原型对象

3.优缺点

优点：

  1. 简单，易于实现

缺点：

  1. 修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。

    可以这样理解：执行sub1.arr.push(2);先对sub1进行属性查找，找遍了实例属性（在本例中没有实例属性），没找到，就开始顺着原型链向上找，拿到了sub1的原型对象，一搜身，发现有arr属性。于是给arr末尾插入了2，所以sub2.arr也变了

  2. 创建子类实例时，无法向父类构造函数传参

二.借用构造函数

简单原型链真够简单，可是存在2个致命缺点简直不能用，于是上个世纪末的jsers就想办法fix这2个缺陷，然后出现了借用构造函数方式

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function Super(val){
    this.val = val;
    this.arr = [1];
 
    this.fun = function(){
        // ...
    }
}
function Sub(val){
    Super.call(this, val);   // 核心
    // ...
}
 
var sub1 = new Sub(1);
var sub2 = new Sub(2);
sub1.arr.push(2);
alert(sub1.val);    // 1
alert(sub2.val);    // 2
 
alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1
 
alert(sub1.fun === sub2.fun);   // false

2.核心

借父类的构造函数来增强子类实例，等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）

3.优缺点

优点：

  1. 解决了子类实例共享父类引用属性的问题

  2. 创建子类实例时，可以向父类构造函数传参

P.S.前辈就这么高效，两个缺陷瞬间修复

缺点：

  1. 无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。。

P.S.好吧，刚修复了共享引用属性的问题，又出现了这个新问题。。

三.组合继承（最常用）

目前我们的借用构造函数方式还是有问题（无法实现函数复用），没关系，接着修复，jsers吭哧吭哧又搞出了组合继承

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
    Super.call(this);   // 核心
    // ...
}
Sub.prototype = new Super();    // 核心
 
var sub1 = new Sub(1);
var sub2 = new Sub(2);
alert(sub1.fun === sub2.fun);   // true

2.核心

把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点，通过Super.call(this);继承父类的基本属性和引用属性并保留能传参的优点；通过Sub.prototype = new Super();继承父类函数，实现函数复用

3.优缺点

优点：

  1. 不存在引用属性共享问题
  2. 可传参
  3. 函数可复用

缺点:

  1. （一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费，比刚才情况好点，不过确实是瑕疵

P.S.如果无法理解这个”多余“，可以查看黯羽轻扬：JS学习笔记2_面向对象，文章末尾有更详细的解释

四.寄生组合继承（最佳方式）

从名字就能看出又是对组合继承的优化，不是说组合继承有瑕疵吗，没关系，我们接着追求完美

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
    Super.call(this);   // 核心
    // ...
}
var proto = beget(Super.prototype); // 核心
proto.constructor = Sub;            // 核心
Sub.prototype = proto;              // 核心
 
var sub = new Sub();
alert(sub.val);
alert(sub.arr);

P.S.等等，生孩子函数是啥东西，怎么没听过？还有标明了核心的3句话，怎么没看明白？别着急，我们喝杯茶接着看

2.核心

用beget(Super.prototype);切掉了原型对象上多余的那份父类实例属性

P.S.啥？没看明白？哦哦~，忘记说原型式和寄生式继承了，就说怎么总觉得忘了锁门。。这记性

P.S.寄生组合式继承，这名字不是很贴切，和寄生式继承关系并不是特别大

3.优缺点

优点：完美了

缺点：理论上没有了（如果用起来麻烦不算缺点的话。。）

P.S.用起来麻烦是一方面，另一方面是因为寄生组合式继承出现的比较晚，是21世纪初的东西，大家等不起这么久，所以组合继承是最常用的，而这个理论上完美的方案却只是课本上的最佳方式了

五.原型式

其实介绍完上面的完美方案就可以结束了，但从组合继承到完美方案好像有一段不小的思维跳跃，有必要把故事说清楚

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    this.val = 1;
    this.arr = [1];
}
 
// 拿到父类对象
var sup = new Super();
// 生孩子
var sub = beget(sup);   // 核心
// 增强
sub.attr1 = 1;
sub.attr2 = 2;
//sub.attr3...
 
alert(sub.val);     // 1
alert(sub.arr);     // 1
alert(sub.attr1);   // 1

P.S.诶~看到了没，生孩子函数beget出现了

2.核心

用生孩子函数得到得到一个“纯洁”的新对象（“纯洁”是因为没有实例属性），再逐步增强之（填充实例属性）

P.S.ES5提供了Object.create()函数，内部就是原型式继承，IE9+支持

3.优缺点

优点：

  1. 从已有对象衍生新对象，不需要创建自定义类型（更像是对象复制，而不是继承。。）

缺点：

  1. 原型引用属性会被所有实例共享，因为是用整个父类对象来充当了子类原型对象，所以这个缺陷无可避免

  2. 无法实现代码复用（新对象是现取的，属性是现添的，都没用函数封装，怎么复用）

P.S.这东西和继承有很大关系吗？为什么尼古拉斯把它也列为实现继承的一种方式？关系不大，但有一定关系

六.寄生式

这名字太扯了，而且寄生式是一种模式（套路），并不是只能用来实现继承

1.具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    this.val = 1;
    this.arr = [1];
}
function getSubObject(obj){
    // 创建新对象
    var clone = beget(obj); // 核心
    // 增强
    clone.attr1 = 1;
    clone.attr2 = 2;
    //clone.attr3...
 
    return clone;
}
 
var sub = getSubObject(new Super());
alert(sub.val);     // 1
alert(sub.arr);     // 1
alert(sub.attr1);   // 1

2.核心

给原型式继承穿了个马甲而已，看起来更像继承了（上面介绍的原型式继承更像是对象复制）

注意：beget函数并不是必须的，换言之，创建新对象 -> 增强 -> 返回该对象，这样的过程叫寄生式继承，新对象是如何创建的并不重要（用beget生的，new出来的，字面量现做的。。都可以）

3.优缺点

优点：

  1. 还是不需要创建自定义类型

缺点：

  1. 无法实现函数复用（没用到原型，当然不行）

P.S.剧情解析：有缺陷的寄生式继承 + 不完美的组合继承 = 完美的寄生组合式继承，不妨回去找找看哪里用到了寄生

七.6种继承方式的联系

 

P.S.虚线表示辅助作用，实线表示决定性作用

js的5种继承方式——前端面试

js主要有以下几种继承方式：对象冒充，call()方法，apply()方法，原型链继承以及混合方式。下面就每种方法就代码讲解具体的继承是怎么实现的。1、继承第一种方式：对象冒充1functionParent(username){2this.username=username;3this.hello=functi... 查看详情

理解js中是原型链?如何实现继承?

参考技术A1.每个构造函数都有一个原型对象2.每个原型对象都包含一个指向构造函数的指针3.每个实例都包含一个指向原型对象的指针4.查找方式是一层层向上查找直至顶层Object.prototype1.原型链继承2.借用构造函数(call,apply)3.组合... 查看详情

都0202年了，你还不知道javascript有几种继承方式？(代码片段)

...吗？如果没有的话，可以通过阅读本文，帮助你更深刻地理解js的所有继承方式。   js继承总共分成5种，包括构造函数式继承、原型链式继承、组合式继承、寄生式继承和寄生组合式继承。 构造函数式继承 &nbs... 查看详情

js实现继承的5种方式

...语言，实现一种功能往往有多种做法,ECMAScript没有明确的继承机制，而是通过模仿实现的，根据js语言的本身的特性,js实现继承有以下通用的几种方式1.使用对象冒充实现继承(该种实现方式可以实现多继承)实现原理:让父类的构造... 查看详情

js原型继承的几种方式

1.原型链继承2，构造函数继承（对象冒充继承）3，组合继承（原型链继承+构造函数继承）4，原型式继承5.寄生组合式继承一。原型链继承functionShow(){ this.name="run"; } functionRun(){ this.age="20";//Run继承了Show,通过原型，形成... 查看详情

创建线程的6种方式，用lambda表达式你绝对没用过

参考技术A继承Thread类，重新run方法实现Runnable接口，重写run方法通过实现Callable接口，重写call方法，配合FutureTask，可以得到异步执行的结果。直接使用Lambda表达式方式创建多线程，不需要继承或者实现类。（看起来很酷[绿帽子]... 查看详情

js实现继承的几种方式

前言JS作为面向对象的弱类型语言，继承也是其非常强大的特性之一。那么如何在JS中实现继承呢？让我们拭目以待。JS继承的实现方式既然要实现继承，那么首先我们得有一个父类，代码如下：//定义一个动物类functionAnimal(name){/... 查看详情

js继承的7种方法，你学会了吗？(代码片段)

...同学，本文主要写JavaScript中的7种继承方式，深入理解每种方式所存在的问题同时新的方式是如何解决问题的📢非常感谢你的阅读，不对的地方欢迎指正🙏📢愿你生活明朗，万物 查看详情

js继承的7种方法，你学会了吗？(代码片段)

...同学，本文主要写JavaScript中的7种继承方式，深入理解每种方式所存在的问题同时新的方式是如何解决问题的📢非常感谢你的阅读，不对的地方欢迎指正🙏📢愿你生活明朗，万物 查看详情

js实现继承的几种方式（转）

转自：幻天芒的博客前言JS作为面向对象的弱类型语言，继承也是其非常强大的特性之一。那么如何在JS中实现继承呢？让我们拭目以待。JS继承的实现方式既然要实现继承，那么首先我们得有一个父类，代码如下：//定义一个动... 查看详情

js继承的几种方式

JS作为面向对象的弱类型语言，继承也是其非常强大的特性之一。既然要实现继承，那么我们先定义一个父类：//定义一个动物类functionAnimal(name){//属性this.name=name||‘Animal‘;//实例方法this.sleep=function(){alert(this.name+‘正在睡觉！‘... 查看详情

js中原型继承的三种方式

              查看详情

关于js的对象原型继承

javascript中，对象的继承是通过原型去继承。可以这样理解：js中的对象，包含的除了属性和方法，还有一个最基本的原型__proto__对象。这个原型__proto__指向谁，这个对象就继承谁。这是最容易理解对象原型继承的一种方式。如下... 查看详情

js继承

...学者可能比较难理解或者比较乱，先从简单入门，下面是重新整理了一下，不乏有网上其他人的影子1<!DOCTYPEhtml>2<htmllang="en">3<head>4<metacharset="UTF-8">5<title></title>6</head>7<bo 查看详情

学会这5种js函数继承方式，前端面试你至少成功50%

本文分享自华为云社区《人类高质量JS函数继承》，作者：北极光之夜。 。一、前言函数继承是在JS里比较基础也是比较重要的一部分，而且也是面试中常常要问到的。下面带你快速了解JS中有哪几种是经常出现且必须掌握的继... 查看详情

javascript(js)创建对象的模式与继承的几种方式

1.js创建对象的几种方式工厂模式为什么会产生工厂模式，原因是使用同一个接口创建很多对象，会产生大量的重复代码，为了解决这个问题，产生了工厂模式。functioncreatePerson(name,age,job){   varo=newObject();   o... 查看详情

js实现继承的几种方式

1.call(),apply()方法实现继承 call方法的第一个参数的值赋值给类(即方法)中出现的this call方法的第二个参数开始依次赋值给类(即方法)所接受的参数 apply方法的第一个参数和call相同，第二个参数为数组类型，这个数组中... 查看详情

javascript面向对象系列第三篇——实现继承的3种形式

前面的话　　学习如何创建对象是理解面向对象编程的第一步，第二步是理解继承。开宗明义，继承是指在原有对象的基础上，略作修改，得到一个新的对象。javascript主要包括类式继承、原型继承和拷贝继承这三种继承方式。... 查看详情