搞懂 Javascript 继承原理

最新推荐文章于 2022-07-15 15:39:49 发布
最新推荐文章于 2022-07-15 15:39:49 发布
阅读量98 收藏
点赞数
文章标签： javascript ViewUI
原文链接：https://segmentfault.com/a/1190000016542417
版权

在理解继承之前，需要知道 js 的三个东西：

  1. 什么是 JS 原型链
  2. this 的值到底是什么
  3. JS 的new 到底是干什么的

一、什么是 JS 原型链？

我们知道 JS 有对象，比如

    var obj = { name: 'obj' }

我们通过控制台把obj 打印出来：

clipboard.png

我们会发现 obj已经有几个属性（方法）了。那么问题来了：valueOf / toString / constructor 是怎么来？我们并没有给 obj.valueOf 赋值呀。

上面这个图有点难懂，我手画一个示意图：

clipboard.png

我们发现控制台打出来的结果是：

  1. obj本身有一个属性 name (这是我们给它加的)
  2. obj还有一个属性叫做 __proto__(它是一个对象)
  3. obj还有一个属性，包括 valueOf, toString, constructor等
  4. obj.__proto__其实也有一个叫做__proto__的属性(console.log没有显示)，值为 null

现在回到我们的问题：obj 为什么会拥有 valueOf / toString / constructor 这几个属性？

答案： 这跟 __proto__有关 。

当我们「读取」 obj.toString 时，JS 引擎会做下面的事情：

  1. 看看 obj 对象本身有没有 toString 属性。没有就走到下一步。
  2. 看看 obj.__proto__ 对象有没有 toString 属性， 发现 obj.__proto__ 有 toString 属性， 于是找到了，所以 obj.toString实际就是第2步中找到的 obj.__proto__.toString。
  3. 如果 obj.__proto__没有，那么浏览器会继续查看 obj.__proto__.__proto__
  4. 如果 obj.__proto__.__proto__也没有，那么浏览器会继续查看 obj.__proto__.__proto__.__proto__

5.直到找到 toString 或者 proto 为 null。

上面的过程，就是「读」属性的「搜索过程」。而这个「搜索过程」，是连着由 proto 组成的链子一直走的。这个链子，就叫做「原型链」。

共享原型链

现在我们还有另一个对象

var obj2 = { name: 'obj2' }

如图:

clipboard.png

那么 obj.toString 和 obj2.toString 其实是同一东西， 也就是 obj2.__proto__.toString。
说白了，我们改其中的一个 __proto__.toString ，那么另外一个其实也会变!

差异化

如果我们想让 obj.toString 和 obj2.toString 的行为不同怎么做呢？
直接赋值就好了：

obj.toString = function(){ return '新的 toString 方法' }

clipboard.png

小结

  1. [读]属性时会沿着原型链搜索
  2. [新增]属性时不会去看原型链

二、 this 的值到底是什么

你可能遇到过这样的 JS 面试题：

var obj = {
  foo: function(){
    console.log(this)
  }
}

var bar = obj.foo
obj.foo() // 打印出的 this 是 obj
bar() // 打印出的 this 是 window

请解释最后两行函数的值为什么不一样。

函数调用

JS（ES5）里面有三种函数调用形式：

func(p1, p2) 
obj.child.method(p1, p2)
func.call(context, p1, p2) // 先不讲 apply

一般，初学者都知道前两种形式，而且认为前两种形式「优于」第三种形式。
我们方方老师大姥说了，你一定要记住，第三种调用形式，才是正常调用形式：

    func.call(context, p1, p2)

其他两种都是语法糖，可以等价地变为 call 形式：

func(p1, p2)等价于 func.call(undefined, p1, p2);

obj.child.method(p1, p2) 等价于 obj.child.method.call(obj.child, p1, p2);

至此我们的函数调用只有一种形式：

func.call(context, p1, p2)

这样，this 就好解释了 this就是上面 context。

this 是你 call 一个函数时传的 context，由于你从来不用 call 形式的函数调用，所以你一直不知道。

先看 func(p1, p2) 中的 this 如何确定：

当你写下面代码时

function func(){
  console.log(this)
}

func()
等价于

function func(){
  console.log(this)
}

func.call(undefined) // 可以简写为 func.call()

按理说打印出来的 this 应该就是 undefined 了吧，但是浏览器里有一条规则：

如果你传的 context 就 null 或者 undefined，那么 window 对象就是默认的 context（严格模式下默认 context 是 undefined）

因此上面的打印结果是 window。如果你希望这里的 this 不是 window，很简单：

func.call(obj) // 那么里面的 this 就是 obj 对象了

回到题目：

var obj = {
  foo: function(){
    console.log(this)
  }
}

var bar = obj.foo
obj.foo() // 转换为 obj.foo.call(obj)，this 就是 obj
bar() 
// 转换为 bar.call()
// 由于没有传 context
// 所以 this 就是 undefined
// 最后浏览器给你一个默认的 this —— window 对象
[ ] 语法
function fn (){ console.log(this) }
var arr = [fn, fn2]
arr[0]() // 这里面的 this 又是什么呢？

我们可以把 arr0 想象为arr.0( )，虽然后者的语法错了，但是形式与转换代码里的 obj.child.method(p1, p2) 对应上了，于是就可以愉快的转换了：

    arr[0]()

假想为 arr.0()
然后转换为 arr.0.call(arr)
那么里面的 this 就是 arr 了 :)

小结：

  1. this 就是你 call 一个函数时，传入的第一个参数。
  2. 如果你的函数调用不是 call 形式， 请将其转换为 call 形式

三、JS 的 new 到底是干什么的？

我们声明一个士兵，具有如下属性：

var 士兵 = {
  ID: 1, // 用于区分每个士兵
  兵种:"美国大兵",
  攻击力:5,
  生命值:42, 
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

我们制造一个士兵， 只需要这样：

兵营.制造(士兵)

如果需要制造 100 个士兵怎么办呢？

循环 100 次吧：

var 士兵们 = []
var 士兵
for(var i=0; i<100; i++){
  士兵 = {
    ID: i, // ID 不能重复
    兵种:"美国大兵",
    攻击力:5,
    生命值:42, 
    行走:function(){ /*走俩步的代码*/}，
    奔跑:function(){ /*狂奔的代码*/  },
    死亡:function(){ /*Go die*/    },
    攻击:function(){ /*糊他熊脸*/   },
    防御:function(){ /*护脸*/       }
  }
  士兵们.push(士兵)
}

兵营.批量制造(士兵们)

哎呀，看起来好简单

质疑

上面的代码存在一个问题：浪费了很多内存

  1. 行走、奔跑、死亡、攻击、防御这五个动作对于每个士兵其实是一样的，只需要各自引用同一个函数就可以了，没必要重复创建 100 个行走、100个奔跑……
  2. 这些士兵的兵种和攻击力都是一样的，没必要创建 100 次。
  3. 只有 ID 和生命值需要创建 100 次，因为每个士兵有自己的 ID 和生命值。
改进

通过第一节可以知道 ，我们可以通过原型链来解决重复创建的问题：我们先创建一个「士兵原型」，然后让「士兵」的 proto 指向「士兵原型」。

var 士兵原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

var 士兵们 = []
var 士兵
for(var i=0; i<100; i++){
  士兵 = {
    ID: i, // ID 不能重复
    生命值:42
  }

  /*实际工作中不要这样写，因为 __proto__ 不是标准属性*/
  士兵.__proto__ = 士兵原型 

  士兵们.push(士兵)
}

兵营.批量制造(士兵们)
优雅？

有人指出创建一个士兵的代码分散在两个地方很不优雅，于是我们用一个函数把这两部分联系起来：

function 士兵(ID){
  var 临时对象 = {};
  临时对象.__proto__ = 士兵.原型;
  临时对象.ID = ID;
  临时对象.生命值 = 42;
  
  return 临时对象;
}  

士兵.原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js

 然后就可以愉快地引用「士兵」来创建士兵了：

var 士兵们 = []
for(var i=0; i<100; i++){
  士兵们.push(士兵(i))
}

兵营.批量制造(士兵们)

JS 之父看到大家都这么搞，觉得何必呢，我给你们个糖吃，于是 JS 之父创建了 new 关键字，可以让我们少写几行代码：

clipboard.png

只要你在士兵前面使用 new 关键字，那么可以少做四件事情：

  1. 不用创建临时对象，因为 new 会帮你做（你使用「this」就可以访问到临时对象）；
  2. 不用绑定原型，因为new 会帮你做(new 为了知道原型在哪，所以指定原型的名字 prototype);
  3. 不用 return 临时对象，因为 new 会帮你做；
  4. 不要给原型想名字了，因为 new 指定名字为 prototype。
这一次用 new 来写
function 士兵(ID){
  this.ID = ID
  this.生命值 = 42
}

士兵.prototype = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js
然后是创建士兵（加了一个 new 关键字）：

var 士兵们 = []
for(var i=0; i<100; i++){
  士兵们.push(new 士兵(i))
}

兵营.批量制造(士兵们)

new 的作用，就是省那么几行代码。（也就是所谓的语法糖）

注意 constructor 属性

new 操作为了记录「临时对象是由哪个函数创建的」，所以预先给「士兵.prototype」加了一个 constructor 属性：

士兵.prototype = {
  constructor: 士兵
}

如果你重新对「士兵.prototype」赋值，那么这个 constructor 属性就没了，所以你应该这么写：

士兵.prototype.兵种 = "美国大兵"
士兵.prototype.攻击力 = 5
士兵.prototype.行走 = function(){ /*走俩步的代码*/}
士兵.prototype.奔跑 = function(){ /*狂奔的代码*/  }
士兵.prototype.死亡 = function(){ /*Go die*/    }
士兵.prototype.攻击 = function(){ /*糊他熊脸*/   }
士兵.prototype.防御 = function(){ /*护脸*/       }

或者你也可以自己给 constructor 重新赋值：

士兵.prototype = {
  constructor: 士兵,
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

四、继承

继承的本质就是上面的讲的原型链

1)借助构造函数实现继承
 function Parent1() {
   this.name = 'parent1';
 }
 
 Parent1.prototype.say = function () {}
 
 function Child1() {
   Parent1.call(this);
   this.type = 'child';
 }

 console.log(new Child1);

打印结果：

clipboard.png

这个主要是借用call 来改变this的指向，通过 call 调用 Parent ，此时 Parent 中的 this 是指 Child1。有个缺点，从打印结果看出 Child1并没有say方法，所以这种只能继承父类的实例属性和方法，不能继承原型属性/方法。

2)借助原型链实现继承
/**
 * 借助原型链实现继承
 */
function Parent2() {
  this.name = 'parent2';
  this.play = [1, 2, 3];
}

function Child2() {
  this.type = 'child2';
}
Child2.prototype = new Parent2();

console.log(new Child2);

var s1 = new Child2();
var s2 = new Child2();

打印：

clipboard.png

通过一讲的，我们知道要共享莫些属性，需要 对象.__proto__ = 父亲对象的.prototype,但实际上我们是不能直接 操作__proto__，这时我们可以借用 new 来做，所以
Child2.prototype = new Parent2(); <=> Child2.prototype.__proto__ = Parent2.prototype; 这样我们借助 new 这个语法糖，就可以实现原型链继承。但这里有个总是，如打印结果，我们给 s1.play新增一个值 ，s2 也跟着改了。所以这个是原型链继承的缺点，原因是 s1.__pro__ 和 s2.__pro__指向同一个地址即 父类的prototype。

3)组合方式实现继承
/**
 * 组合方式
 */

function Parent3() {
  this.name = 'parent3';
  this.play = [1, 2, 3];
}

Parent3.prototype.say = function () { }

function Child3 () {
  Parent3.call(this);
  this.type = 'child3';
}

Child3.prototype = new Parent3();

var s3 = new Child3();
var s4 = new Child3();
s3.play.push(4);
console.log(new Child3);
console.log(s3.play, s4.play)

打印:

clipboard.png

将 1 和 2 两种方式组合起来，就可以解决1和2存在问题，这种方式为组合继承。这种方式有点缺点就是我实例一个对象的时， 父类 new 了两次，一次是var s3 = new Child3()对应 Child3.prototype = new Parent3()还要new 一次。

4)组合继承的优化1
function Parent4() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent4.prototype.say = function () { }

function Child4() {
  Parent4.call(this);
  this.type = 'child4';
}

Child4.prototype = Parent4.prototype;

var s5 = new Child4();
var s6 = new Child4();

这边主要为 Child4.prototype = Parent4.prototype， 因为我们通过构造函数就可以拿到所有属性和实例的方法，那么现在我想继承父类的原型对象，所以你直接赋值给我就行，不用在去 new 一次父类。其实这种方法还是有问题的，如果我在控制台打印以下两句:

clipboard.png
从打印可以看出，此时我是没有办法区分一个对象 是直接 由它的子类实例化还是父类呢？我们还有一个方法判断来判断对象是否是类的实例，那就是用 constructor,我在控制台打印以下内容：

clipboard.png

咦，你会发现它指向的是父类 ，这显然不是我们想要的结果， 上面讲过我们 prototype里面有一个 constructor, 而我们此时子类的 prototype 指向是 父类的 prototye ,而父类prototype里面的contructor当然是父类自己的，这个就是产生该问题的原因。

组合继承的优化2
/**
 * 组合继承的优化2
 */

function Parent5() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent5.prototype.say = function () { }

function Child5() {
  Parent5.call(this);
  this.type = 'child4';
}

Child5.prototype = Object.create(Parent5.prototype);

这里主要使用Object.create()，它的作用是将对象继承到__proto__属性上。举个例子：

var test = Object.create({x:123,y:345});
console.log(test);//{}
console.log(test.x);//123
console.log(test.__proto__.x);//3
console.log(test.__proto__.x === test.x);//true

那大家可能说这样解决了吗，其实没有解决,因为这时 Child5.prototype 还是没有自己的 constructor,它要找的话还是向自己的原型对象上找最后还是找到 Parent5.prototype, constructor还是 Parent5 ,所以要给 Child5.prototype 写自己的 constructor:

Child5.prototype = Object.create(Parent5.prototype);
Child5.prototype.constructor = Child5;
参考
什么是 JS 原型链？
this 的值到底是什么？一次说清楚
JS 的 new 到底是干什么的？

码部署后可能存在的BUG没法实时知道，事后为了解决这些BUG，花了大量的时间进行log 调试，这边顺便给大家推荐一个好用的BUG监控工具 Fundebug。

你的点赞是我持续分享好东西的动力，欢迎点赞！

一个笨笨的码农，我的世界只能终身学习！

更多内容请关注公众号《大迁世界》！

weixin_34032792
关注
猿创征文｜在工作中彻底搞懂原型和原型链的原理
软贱开发攻城狮
09-01 1431
在前端开发过程中，涉及到JS原理相关的内容也就是常用的几大模块，不仅常用而且很重要，但是涉及到原理的话会有点难懂，尤其是对JS接触不太久的开发者来讲，甚至工作好几年的开发者也只是在平时开发中知道怎么使用，要想让他讲原理也是讲的不完全，所以这就需要我们在开发的时候把原理运用到实际工作中，这样可以起到事半功倍的效果，不仅完成了工作任务也彻底搞清楚了使用原理，岂不美哉？！......
彻底搞懂typescript工具类型及其原理
qq_32438227的博客
05-31 752
前言 相信很多人都在学习typescript，这里介绍泛型常见的工具类型函数(Utility Types)及其在typescript中的源码实现。 工具函数 可能有些刚开始学ts的还不清楚什么工具类型指的是什么，工具类型就是TypeScript提供的一些实用类型来实现常见的类型转换，这些类型是全局可用的，所有的类型定义在typescript源码中也都能找到。 Partial Partial<T>，将传入T类型的所有属性设为可选属性。 例如下面的实例代码，定义一个user接口类型，通过Partia
js继承的方法及原理
qq_60551458的博客
11-17 1289
js继承的方法及原理 1.原型链继承 原理：父类的实例作为子类的原型 function Woman(){ } Woman.prototype= new People(); Woman.prototype.name = 'haixia'; let womanObj = new Woman(); 【优点】简单易于实现，父类的新增的实例与属性子类都能访问 【缺点】1.如果要新增原型属性和方法需要在new父类构造函数的后面，无法实现多继承 ​ 2.创建子类实例时，不能向父类构造函数
【转载】Javascript继承机制的设计思想
allen_dream的专栏
05-18 531
由 HTML5研究小组 于 周五, 10:52 上午 发表分类: HTML5 技术博文, HTML5学习资源 作者： 阮一峰 日期： 2011年6月 5日   我一直很难理解Javascript语言的继承机制。 它没有”子类”和”父类”的概念，也没有”类”（class）和”实例”（instance）的区分，全靠一种很奇特的”原型
JavaScript原型继承工作原理
hsany330的专栏
10-27 5178
译者按：这篇文章原是出自著名的前端博主阮一峰一篇关于JS原型继承的文章：Javascript继承机制的设计思想中的引用。这篇文章对于原型继承讲解详细，令人读之有拨云见日之感，作者在文章里说： 我一直很难理解Javascript语言的继承机制。 它没有“子类”和“父类”的概念，也没有“类”（class）和“实例”（instance）的区分，全靠一种很奇特的“原型链”（prototyp
js继承原理
陈天天
10-10 776
- 传统方法// 参数为两个类 function extend(subClass,superClass) { var f=function(){} f.prototype=superClass.prototype; subClass.prototype=new f(); // 将子类的原型对象的构造类指向自己的类 subCl
JavaScript你一定要搞懂的原型链
最新发布
09-23
通过掌握原型链的概念和工作原理，开发者可以更好地利用 JavaScript 的面向对象特性。 这是一个可编辑的xmind文件，对原型链有清晰的勾画，不同的链用不同颜色进行了标识，内容一目了然，可以帮助快速学习原型链。
一篇文章带你搞懂JavaScript原型对象
流楚丶格念的博客
09-28 4592
文章目录原型对象`prototype`属性构造函数、实例、原型三者之间的关系属性成员的搜索原则：==原型链==实例对象读写原型对象成员更简单的原型语法原生对象的原型原型对象的问题原型对象使用建议原型对象的作用：共享数据,节省内存空间__proto__与prototype区分小案例案例：随机方块补充：把局部变量变成全局变量方法：把局部变量给window案例实现 原型对象 prototype属性 Javascript 规定，每一个构造函数都有一个 prototype 属性，指向另一个对象。 这个对象的所有属性和
学透JavaScript 你真的懂 Array 吗？
LuZhenQian2017的博客
03-09 1896
前言 科普 JavaScript，揭开 JavaScript 神秘面纱，直击 JavaScript 灵魂。此系列文章适合任何人阅读。 本文章内容为： 标准化数组。 数组与数组容器。 ECMAScript 规范中 Array API 讲解。 如果你想用 Array，而又不想学 API 的办法。 标准规范以外的 Array API 扩展。 V8 引擎对 Array 的处...
js继承原理(必看)
chelen_jak的专栏
12-29 722
ECMAScript 定义类或对象  http://www.w3school.com.cn/js/pro_js_object_defining.asp
JS继承原理剖析
qq_42259940的博客
11-12 173
1、原型链继承 构造函数、原型和实例之间的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个原型对象的指针。 继承的本质就是复制，即重写原型对象，代之以一个新类型的实例。 function SuperType() { this.property = true; } SuperType.prototype.getSuperValue = functi...
JavaScript继承方式及原理
bigname22的博客
08-04 358
继上篇文章深入剖析prototype、constructor、_proto_原理后，接下来整理、理解JS中的继承就水到渠成，一气呵成！ 话不多说，上个文章中说过，原型链最主要就是为了解决JS在面向对象中继承功能的实现。所以在js继承中第一种要介绍的方式当然是从原型链继承。过程中会插入我对该种继承产生过的一些疑惑并作出解答，希望这对你的理解能带来帮助 原型链继承： function Father () { this.name = 'father'; } .
JS 继承
sinat_28839863的博客
03-18 436
本文大部分参考自https://www.cnblogs.com/chengzp/p/prototype.html 原型链 简单理解就是原型组成的链，实例的__proto__是它的原型，而原型也是一个对象，也有__proto__属性，原型的__proto__又是原型的原型，就这样可以一直通过__proto__想上找，直到最后的null，这就是原型链，当向上找找到Object的原型（null）...
js 继承原理【终极】
shijunf_007的博客
02-28 75
function Person(name, age) { this.age = age this.name = name } Person.prototype.say = function () { console.log("Hello World"); } function Student(name, age, score) { // 继承 Person.call(this, name, age) this.score = score thi.
JS中5种经典继承方式
weixin_30426065的博客
01-20 370
继承 JS中继承的概念： 通过【某种方式】让一个对象可以访问到另一个对象中的属性和方法，我们把这种方式称之为继承 并不是所谓的xxx extends yyy 为什么要使用继承？ 有些对象会有方法(动作、行为)，而这些方法都是函数，如果把这些方法和函数都放在构造函数中声明就会导致内存的浪费 function Person(){ this.say=function(){...
Javascript继承的原理
weixin_46279019的博客
07-15 452
Javascript继承的原理，原型与原型链
详解JS继承，从原理入手到五种 js 实现继承方式
圆圆的 JavaScript 博客
07-13 529
javascript继承的几种方法：原型链继承，其重点是让新实例的原型等于父类的实例；借用构造函数继承（也称伪造对象或经典继承）；组合继承（组合原型链继承和借用构造函数继承）；寄生组合式继承（完美⽅式）。
JS继承机制--写的比较通俗易懂，一系列文章看文对于你对于JS继承机制的理解会加深很多
ben_gmail的专栏
06-07 4777
Javascript继承机制的设计思想作者： 阮一峰日期： 2011年6月 5日我一直很难理解Javascript语言的继承机制。它没有"子类"和"父类"的概念，也没有"类"（class）和"实例"（instance）的区分，全靠一种很奇特的"原型链"（prototype chain）模式，来实现继承。我花了很多时间，学习这个部分，还做了很多
JavaScript继承原理与实践：示例解析
本文将详细介绍JavaScript的继承机制，特别是原型链的原理。 ### 原型链(Prototype Chaining) 原型链是JavaScript实现继承的主要方式之一，它基于原型对象的连接形成一个链状结构。每个函数（即构造函数）都有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值