菜单

轻松学习JavaScript十三:JavaScript基于面向对象之继续(包罗面向对象继承机制)

2019年3月28日 - 金沙前端

击败 JavaScript 面试:类继承和原型继承的差异

2017/01/30 · JavaScript
· 继承

原来的书文出处: Eric
Elliott   译文出处:众成翻译   

图片 1

图-电子吉他-Feliciano Guimarães(CC BY 2.0)

“战胜JavaScript面试”是自己所写的二个多元小说,目的在于救助那2个应聘中、高级JavaScript开发职位的读者们预备一些广阔的面试标题。小编要还好其实面试个中也不时会问到那类难题。体系的率先篇小说请参见“什么是闭包”

注:本文均以ES6专业做代码举例。假设想掌握ES6,能够参见“ES6学习指南”

初稿链接:https://medium.com/javascript-scene/master-the-javascript-interview-what-s-the-difference-between-class-prototypal-inheritance-e4cd0a7562e9\#.d84c324od

目的在JavaScript语言中选拔越发大规模,学会怎么有效地应用对象,有助于工效的升迁。而不行的面向对象设计,恐怕会促成代码工程的挫败,更要紧的话还会引发万事公司喜剧

分裂于别的大多数语言,JavaScript是根据原型的对象系统,而不是依据。遗憾的是,一大半JavaScript开发者对其目的系统精晓不到位,恐怕难以特出地使用,总想遵照类的办法利用,其结果将招致代码里的目的使用混乱不堪。所以JavaScript开发者最棒对原型和类都能享有领悟。

图片 2

自在学习JavaScript十三:JavaScript基于面向对象之继续(蕴含面向对象继承机制)

一面相目的继承机制

明日终于怎么都没干,尽在打听面向对象三大特点之一的接轨了,过去的上学的C++和C#都以正式的面向对象语

言,学习的时候也从没怎么深远摸底过,只是简短的求学最基础的后续。上午在看后续机制的时候,看到三个很经典

的接二连三机制实例。那么些实例使用UML很好的诠释了连续机制。

申明继承机制最简便易行的办法是,利用一个经典的例子正是几何样子。实际上,几何样子只有二种,即椭圆形(是圆

形的)和多方形(具有自然数量的边)。圆是椭圆的一种,它唯有3个纽带。三角形、矩形和五边形都以多方面形的一种,

装有不一致数量的边。星型是矩形的一种,全体的边等长。那就构成了一种完美的接轨关系,很好的表达了面向对象

的一连机制。

在这些事例中,形状是纺锤形和多方形的基类(平常我们也得以叫它父类,所有类都由它一连而来)。椭圆具有一

个属性(foci),表达椭圆具有的要害的个数。圆形继承了星型,由此圆形是椭圆形的子类,星型是圈子的超类。同

样,三角形、矩形和五边形都是多方面形的子类,多边形是它们的超类。最终,星型继承了矩形。

最棒用图来诠释那种持续关系,那是
UML(统第叁建工公司模语言)的用武之地。UML的首要用途之一是,可视化地意味着像

持续那样的错综复杂对象关联。上面包车型大巴图示是分解形状和它的子类之间关系的UML图示:

图片 3

在UML中,各种方框表示三个类,由类名表明。三角形
、矩形和五边形顶部的线条汇聚在同步,指向形状,表明

那几个类都由形态继承而来。同样,从纺锤形指向矩形的箭头表达了它们中间的接轨关系。

二ECMAScript继承机制的兑现

要用ECMAScript实现持续机制,您能够从要继承的基类出手。全数开发者定义的类都可视作基类。出于安全原

因,本地类和宿主类不能够看做基类,这样能够预防公用访问编写翻译过的浏览器级的代码,因为那一个代码可以被用来恶意

攻击。

选定基类后,就足以创设它的子类了。是或不是选取基类完全由你控制。有时,你只怕想制造三个不可能直接选拔的基

类,它只是用于给子类提供通用的函数。在那种场地下,基类被用作抽象类。就算ECMAScript并从未像任何语言那样

惨酷地定义抽象类,但神蹟它的确会成立一些不容许选取的类。平常,大家称那种类为抽象类。

创办的子类将继续超类的拥有属性和方法,包涵构造函数及办法的兑现。记住,全体属性和章程都以公用的,因

此子类可径直访问这么些措施。子类还可添加超类中一向不的新属性和章程,也足以覆盖超类的品质和措施。由于JS并不

是规范的面向对象语言,一些名词也急需做出改变。

三ECMAScript继承的方法

ECMAScript语言元帅被持续的类(基类)称为超类型,子类(或派生类)称为子类型。和其余职能雷同,ECMAScript

福寿绵绵持续的艺术持续一种。那是因为JavaScript中的继承机制并不是显明规定的,而是通过模拟达成的。那象征所

部分两次三番细节并非全盘由解释程序处理。作为开发者,你有权决定最适用的后续情势。上边为您介绍三种具体的接轨

方式。
(1)原型链格局

继续那种样式在ECMAScript中原来是用来原型链的。上一篇博文已经介绍了创制对象的原型格局。原型链扩充了

那种方法,以一种有趣的措施完毕一连机制。prototype
对象是个模板,要实例化的靶子都是那些模板为根基。总而

言之,prototype
对象的任何性质和方式都被传送给那多少个类的具备实例。原型链利用这种效果来达成持续机制。大家

来看一个例证:

 

function A() {//超类型A中必须没有参数
    this.color = "red";
    this.showColor = function () {
       return this.color;
    };
};
function B() {//子类型B
    this.name = "John";
    this.showName = function () {
       return this.name;
    };
};
B.prototype = new A();//子类型B继承了超类型A,通过原型,形成链条
var a = new A();
var b = new B();
document.write(a.showColor());//输出:blue
document.write(b.showColor());//输出:red
document.write(b.showName());//输出:John

在原型链中,instanceof运算符的运作方式也很奇特。对B的具有实例,instanceof为A和B都回来true。

 

ECMAScript的弱类型世界中,那是最棒有用的工具,但是使用对象冒充时无法选取它。例如:

 

var b = new B();
document.write(b instanceof A);//输出:true
document.write(b instanceof B);//输出:true

应用原型链方式完结了三番五次,可是那种格局不可能共享和子类型给超类型传递参数。大家得以借用构造函数格局(也

 

尽管对像冒充)的措施来消除那四个难题。

(2)对象冒充艺术

目的冒充艺术的其规律如下:构造函数使用this关键字给拥有属性和艺术赋值(即选用对象注脚的构造函数格局)。

因为构造函数只是三个函数,所以可使A构造函数成为B的点子,然后调用它。B就会收到A的构造函数中定义的品质

和章程。例如,用上边包车型大巴方法改写上边的例子成立对象A和B:
1call()方法

function A(Color) {//创建超类型A
    this.color = Color;
    this.showColor = function () {
          return this.color;
    };
};
function B(Color,Name) {//创建子类型B
    A.call(this, Color);//对象冒充,给超类型传参
    this.name = Name;//新添加的属性
    this.showName = 
};
var a = new A("blue");
var b = new B("red", "John");
document.write(a.showColor());//输出:blue
document.write(b.showColor());//输出:red
document.write(b.showName());//输出:John

2apply()方法

 

和上边call()方法唯一的差别就是在子类型B中的代码:

 

A.call(this,arguments);//对象冒充,给超类型传参

 

理所当然,唯有超类型中的参数顺序与子类型中的参数顺序完全一致时才得以传递参数对象。如若不是,就不可能不创设

1个独立的数组,遵照科学的依次放置参数。

选择对象冒充艺术就算缓解了共享和传参的标题,可是从未原型,复用就更不容许了,所以我们构成上述的三种

方法,即原型链格局和对象冒充的法子贯彻JS的继承。

(3)混合情势

那种持续情势使用构造函数定义类,并非使用别的原型。对象冒充的重要难题是必须利用构造函数情势,那不是

最棒的挑三拣四。可是假如使用原型链,就不可能选择带参数的构造函数了。开发者怎样选拔啊?答案很粗略,两者都用。

由于那种混合方式使用了原型链,所以instanceof运算符还可以科学生运动维。

在上一篇博文,创造对象的最佳方式是用构造函数定义属性,用原型定义方法。那种措施相同适用于继续机制,

用对象冒充继承构造函数的天性,用原型链继承prototype对象的措施。用那两种方法重写前面包车型地铁事例,代码如下:

 

function A(Color) {
    this.color = Color;
};
A.prototype.showColor = function () {
    return this.color;
};
function B(Color, Name) {
    A.call(this, Color);//对象冒充
    this.name = Name;
};
B.prototype = new A();//使用原型链继承
B.prototype.showName = function () {
    return this.name;
};
var a = new A("blue");
var b = new B("red", "John");
document.write(a.showColor());//输出:blue
document.write(b.showColor());//输出:red
document.write(b.showName());//输出:John

此起彼伏的法子和创设对象的法子有一定的牵连,推荐应用的一连情势还时原型链和对象冒充的交集形式。使用那种

 

错落格局可防止止某个不需要的标题。

看那篇博文的时候,必须看一下前方的创立对象的方法:轻松学习JavaScript十二:JavaScript基于面向对象之创

建对象(一)和自在学习JavaScript十二:JavaScript基于面向对象之创立对象(二)。那么领会起来应当没有那么难了,

JS面向对象的部分定义时须求我们回过头来再明白的。
 

)
一面相对象继承机制 前几日好不不难什么都没干,尽在摸底面向对象…

一 、面相对象继承机制
      那些实例使用UML很好的诠释了继续机制。
     
表明继承机制最简便的不二法门是,利用2个经文的例子正是几何样子。实际上,几何样子唯有三种,即星型(是圈子的)和多边形(具有自然数量的边)。圆是椭圆的一种,它唯有四个典型。三角形、矩形和五边形都以多方面形的一种,具有不相同数量的边。椭圆形是矩形的一种,全数的边等长。这就构成了一种完美的后续关系,很好的分解了面向对象的接轨机制。
      
在这些例子中,形状是正方形和多边形的基类(平时大家也足以叫它父类,全部类都由它再三再四而来)。椭圆具有3个属(foci),表达椭圆具有的症结的个数。圆形继承了圆锥形,由此圆形是纺锤形的子类,纺锤形是圈子的超类。同样,三角形、矩形和五边形都是多方面形的子类,多边形是它们的超类。最终,星型继承了矩形。
      最棒用图来分解那种持续关系,那是
UML(统一建模语言)的用武之地。UML的首要用途之一是,可视化地代表像继承那样的繁杂对象关联。下边包车型地铁图示是解释形状和它的子类之间关系的UML图示:

类继承和原型继承有什么不一致?

其一难点比较复杂,大家有大概会在评论区各持己见、莫衷一是。因而,列位看官须要打起十分的饱满学习个中差距,并将所学特出地运用到实践其中去。

类继承:能够把类比作一张蓝图,它形容了被创造对象的性质及特色。

公开场合,使用new根本字调用构造函数能够创建类的实例。在ES6中,不用class最主要字也得以实现类继承。像Java语言中类的概念,从技术上来说在JavaScript中并不存在。可是JavaScript借鉴了构造函数的商讨。ES6中的class要害字,也就是是建立在构造函数之上的一种包装,其本质还是是函数。

JavaScript

class Foo {} typeof Foo // ‘function’

1
2
class Foo {}
typeof Foo // ‘function’

虽说JavaScript中的类继承的兑现建立在原型继承之上,不过并不意味二者持有相同的效果:

JavaScript的类继承使用原型链来连接子类和父类的
[[Prototype]],从而形成代理格局。平时景况下,super()_构造函数也会被调用。这种机制,形成了单纯性继承结构,以及面向对象设计中最严密的耦合行为

“类之间的接轨关系,致使了子类间的交互关系,从而形成了——基于层级的分类。”

原型继承: 原型是做事指标的实例。指标直接从任何对象继承属性。

原型继承格局下,对象实例能够由四个指标源所组成。那样就使得后续变得更其灵敏且[[Prototype]]代理层级较浅。换言之,对于基于原型继承的面向对象设计,不会发出层级分类那样的副效率——那是分别于类继承的关键所在。

对象实例日常由工厂函数大概Object.create()来创制,也得以平昔动用Object字面定义。

原型是做事目的的实例。对象直接从任何对象继承属性。”

JavaScript

图片 4

为何搞清楚类继承和原型继承很重庆大学?

延续,本质上讲是一种代码重用机制——各类对象能够借此来共享代码。要是代码共享的点子分选不当,将会抓住过多问题,如:

选择类继承,会发生父-子对象分类的副效用

那类别继承的层系划分体系,对于新用例将不可制止地出现难题。而且基类的过度派生,也会招致薄弱基类问题,其错误将难以修复。事实上,类继承会引发面向对象程序设计领域的过多难点:

对于那个标题作者曾做过深入商讨:“类继承已是今天金蕊——斟酌基于原型的面向对象编程思想”

“优先选拔对象组合而不是类继承。”
~先驱多少人,《设计格局:可复用面向对象软件之道》

在那之中很好地总计了:

一. 重新认识面向对象

      在UML中,每一个方框表示三个类,由类名表达。三角形
、矩形和五边形顶部的线条汇聚在共同,指向形状,表达这么些类都由造型继承而来。同样,从长方形指向矩形的箭头表达了它们之间的一连关系。
二 、ECMAScript继承机制的兑现
     
要用ECMAScript完结三番五次机制,您可以从要延续的基类入手。全数开发者定义的类都可视作基类。出于安全原因,本地类和宿主类不可能作为基类,那样能够预防公用访问编写翻译过的浏览器级的代码,因为那么些代码可以被用于恶意抨击。
      
选定基类后,就足以创设它的子类了。是还是不是利用基类完全由你说了算。有时,你恐怕想创设叁个不能够平素运用的基类,它只是用于给子类提供通用的函数。在那种场馆下,基类被看做抽象类。固然ECMAScript并没有像其余语言那样严格地定义抽象类,但有时候它的确会创立一些差别意使用的类。日常,大家称那连串为抽象类。
     
成立的子类将延续超类的富有属性和格局,包含构造函数及艺术的贯彻。记住,全部属性和办法都是公用的,由此子类可径直访问这几个措施。子类还可添加超类中一直不的新属性和措施,也能够覆盖超类的属性和艺术。由于JS并不是正经的面向对象语言,一些名词也需求做出改变。
三 、ECMAScript继承的法门
     
ECMAScript语言军长被接续的类(基类)称为超类型,子类(或派生类)称为子类型。和其他功能雷同,ECMAScript完成持续的点子持续一种。那是因为JavaScript中的继承机制并不是鲜明规定的,而是经过模拟达成的。这表示全体的再三再四细节并非全盘由解释程序处理。作为开发者,你有权决定最适用的接续情势。上面为你介绍两种具体的继承格局。
(1)原型链格局
     
继承那种样式在ECMAScript中本来是用于原型链的。上一篇博文已经介绍了创设对象的原型格局。原型链扩展了那种措施,以一种有趣的方法贯彻持续机制。prototype
对象是个模板,要实例化的指标都是那一个模板为根基。简单来说,prototype
对象的任何性质和方式都被传送给那贰个类的保有实例。原型链利用那种效果来贯彻延续机制。大家来看一个例证:

是还是不是享有的三番五次格局都有标题?

人们说“优先采取对象组合而不是继续”的时候,其实是要抒发“优先选取对象组合而不是类继承”(引用自《设计情势》的初稿)。该考虑在面向对象设计领域属于常见共识,因为类继承形式的纯天然弱点,会造成不足为奇题材。人们在谈到持续的时候,总是习惯性地总结以此字,给人的感觉像是在针对全体的接续格局,而实在并非如此。

因为多数的继续格局照旧很棒的。

1. JavaScript是一门面向对象的言语

在表明JavaScript是贰个面向对象的言语在此以前,
大家来探索一上边向对象的三大基本特征: 封装, 继承, 多态

封装

把抽象出来的属性和对艺术结合在共同, 且属性值被保险在里边,
唯有因此特定的主意开始展览更改和读取称为包装

大家以代码举例, 首先大家组织二个Person构造函数,
它有nameid三个天性, 并有四个sayHi方法用于打招呼:

//定义Person构造函数
function Person(name, id) {
  this.name = name;
  this.id = id;
}

//在Person.prototype中加入方法
Person.prototype.sayHi = function() {
  console.log('你好, 我是' +  this.name);
}

以往大家转变1个实例对象p1, 并调用sayHi()方法

//实例化对象
let p1 = new Person('阿辉', 1234);

//调用sayHi方法
p1.sayHi();

在上述的代码中, p1本条目的并不知道sayHi()本条方式是何等达成的,
不过依然能够使用那几个方法. 那实质上正是封装.
你也足以达成目的属性的私家和国有,
大家在构造函数中宣称一个salary用作个体属性,
有且只有因而getSalary()情势查询到薪给.

function Person(name, id) {
  this.name = name;
  this.id = id;
  let salary = 20000;
  this.getSalary = function (pwd) {
    pwd === 123456 ? console.log(salary) : console.log('对不起, 你没有权限查看密码');
  }
}

继承

能够让某些项指标目的获得另1个类其余对象的性情和办法称为继承

以刚才的Person用作父类构造器, 大家来新建三个子类构造器Student,
那里大家应用call()措施达成一连

function Student(name, id, subject) {
  //使用call实现父类继承
  Person.call(this, name, id);
  //添加子类的属性
  this.subject = subject;
}

let s1 = new Student('阿辉', 1234, '前端开发');

多态

同等操作效能于分化的靶子发生分歧的履行结果, 那叫做多态

JavaScript中等学校函授数没有重载, 所以JavaScript中的多态是靠函数覆盖完毕的。

如出一辙以刚才的Person构造函数为例,
大家为Person构造函数添加三个study方法

function Person(name, id) {
  this.name = name;
  this.id = id;
  this.study = function() {
    console.log(name + '在学习');
  }
}

一样, 咱们新建贰个StudentTeacher构造函数, 该构造函数继承Person,
并也丰硕study方法

function Student(subject) {
  this.subject = subject;
  this.study = function() {
    console.log(this.name + '在学习' + this.subject);
  }
}
Student.prototype = new Person('阿辉', 1234);
Student.prototype.constructor = Student;

function Teacher(subject) {
  this.subject = subject;
  this.study = function() {
    console.log(this.name + '为了教学而学习' + this.subject);
  }
}
Teacher.prototype = new Person("老夫子", 4567);
Teacher.prototype.constructor = Teacher;

测试咱们新建1个函数doStudy

function doStudy(role) {
  if(role instanceof Person) {
    role.study();
  }
}

那儿大家分别实例化StudentTeacher, 并调用doStudy方法

let student = new Student('前端开发');
let teacher = new Teacher('前端开发');

doStudy(student); //阿辉在学习前端开发
doStudy(teacher); //老夫子为了教学在学习前端开发

对于同一函数doStudy, 由于参数的比不上,
导致分化的调用结果,那就兑现了多态.

JavaScript的面向对象
从位置的分析能够论证出, JavaScript是一门面向对象的言语,
因为它完毕了面向对象的保有性情. 其实,
面向对象仅仅是3个定义或许二个编制程序思想而已, 它不应当依靠于有个别语言存在,
比如Java采取面向对象思想构造其语言, 它完成了类, 继承, 派生, 多态,
接口等机制. 不过那些机制,只是完结面向对象的一种手段,
而非必须。换言之,
一门语言能够遵照自家特色采取稳妥的措施来贯彻面向对象。
由于多数程序员首先学习的是Java, C++等高档编制程序语言,
由此先入为主的承受了“类”这么些面向对象实际方法,所以习惯性的用类式面向对象语言中的概念来判定该语言是或不是是面向对象的言语。那也是无数有其余编程语言经验的人在攻读JavaScript对象时,感觉到很难堪的位置。

实则,
JavaScript是经过一种叫原型(prototype)的方法来贯彻面向对象编制程序的。下边大家就来钻探一下传说类(class-basesd)的面向对象基于原型(protoype-based)的面向对象那四头的出入。

function A() {//超类型A中必须没有参数 
 this.color = "red"; 
 this.showColor = function () { 
  return this.color; 
 }; 
}; 
function B() {//子类型B 
 this.name = "John"; 
 this.showName = function () { 
  return this.name; 
 }; 
}; 
B.prototype = new A();//子类型B继承了超类型A,通过原型,形成链条 
var a = new A(); 
var b = new B(); 
document.write(a.showColor());//输出:blue 
document.write(b.showColor());//输出:red 
document.write(b.showName());//输出:John 

三种分化的原型继承形式

在深切探讨其余后续类型之前,还亟需先仔细分析下自身所说的类继承

您可以在Codepen上找到并测试下那段演示程序

BassAmp 继承自 GuitarAmp, ChannelStrip 继承自 BassAmp
GuitarAmp。从那个例子大家得以看看面向对象设计产生难点的历程。ChannelStrip实际上并不是GuitarAmp的一种,而且它根本不须要2个cabinet的性质。七个比较好的化解办法是开创3个新的基类,供amps和strip来再三再四,可是那种措施还是拥有局限。

到终极,选拔新建基类的方针也会失效。

更好的章程正是因而类组合的措施,来三番五次那多少个的确必要的属性:

修改后的代码

当真看这段代码,你就会发现:通过对象组合,大家得以适量地确认保障对象可以按需后续。那或多或少是类继承形式不只怕形成的。因为使用类继承的时候,子类会把供给的和不必要的性质统统继承过来。

那儿你只怕会问:“唔,是那么回事。不过那里头怎么没涉及原型啊?”

顾客莫急,且听本人一步步行道路来~首先你要精通,基于原型的面向对象设计情势总共有三种。

  1. 东拼西凑继承:
    是直接从三个目的拷贝属性到另三个指标的情势。被拷贝的原型平时被称呼mixins。ES6为这些格局提供了一个方便人民群众的工具Object.assign()。在ES6以前,一般选取Underscore/Lodash提供的.extend(),或者
    jQuery 中的$.extend(),
    来达成。上边10分目的组合的事例,采纳的正是东拼西凑继承的方法。
  2. 原型代理:JavaScript中,3个对象恐怕带有1个针对性原型的引用,该原型被称作代理。假设某些属性不设有于当下目的中,就会寻找其代理原型。代理原型自个儿也会有协调的代理原型。那样就形成了一条原型链,沿着代理链向上查找,直到找到该属性,大概找到根代理Object.prototype告竣。原型正是这么,通过动用new根本字来创设实例以及Constructor.prototype上下勾连成一条继承链。当然,也得以动用Object.create()来达到平等的目标,或许把它和拼接继承混用,从而得以把两个原型精简为单纯代理,也得以完结在对象实例创制后持续壮大。
  3. 函数继承:在JavaScript中,任何函数都得以用来成立对象。要是一个函数既不是构造函数,也不是
    class,它就被号称厂子函数。函数继承的工作规律是:由工厂函数成立对象,并向该指标直接添加属性,借此来扩大对象(使用拼接继承)。函数继承的概念开始由DougRuss·克罗克福德提议,然则那种持续方式在JavaScript中却早已有之。

那时候你会发现,东拼西凑继承是JavaScript能够落实目的组合的诀窍,也使得原型代理和函数继承越发丰裕多彩。

大部分人谈起JavaScript面向对象设计时,首先想到的都以原型代理。可是你看,可不只唯有原型代理。要取代类继承,原型代理照旧得靠边站,指标组合才是中流砥柱

2. 基于类的面向对象和基于原型的面向对象的相比

听大人讲类的面向对象

在基于的面向对象语言中(比如Java和C++),
是创设在类(class)实例(instance)上的。其中概念了富有用于全数某一特点对象的属性。是空泛的事物,
而不是其所描述的全方位目的中的任何特定的民用。另一方面,
三个实例是一个的实例化,是当中的三个分子。

基于原型的面向对象
在基于原型的语言中(如JavaScript)并不设有那种不一样:它只有对象!任凭是构造函数(constructor),实例(instance),原型(prototype)本人都以指标。基于原型的言语具有所谓的原型对象的定义,新对象足以从中获得原始的属性。

据此,在JavaScript中有三个很风趣的__proto__天性(ES6以下是非标准化准属性)用于访问其原型对象,
你会意识,上面提到的构造函数,实例,原型本人都有__proto__针对原型对象。其最终顺着原型链都会指向Object本条构造函数,不过Object的原型对象的原型是null,不信,
你能够尝尝一下Object.prototype.__proto__ === nulltrue。然而typeof null === 'object'true。到那边,
作者深信不疑你应该就能驾驭为啥JavaScript那类基于原型的言语中没有类和实例的区分,
而是万物皆对象!

差别总结

基于类的(Java) 基于原型的(JavaScript)
类和实例是不同的事物。 所有对象均为实例。
通过类定义来定义类;通过构造器方法来实例化类。 通过构造器函数来定义和创建一组对象。
通过 new 操作符创建单个对象。 相同
通过类定义来定义现存类的子类, 从而构建对象的层级结构 指定一个对象作为原型并且与构造函数一起构建对象的层级结构
遵循类链接继承属性 遵循原型链继承属性
类定义指定类的所有实例的所有属性。无法在运行时动态添加属性 构造器函数或原型指定初始的属性集。允许动态地向单个的对象或者整个对象集中添加或移除属性。

     
在原型链中,instanceof运算符的周转格局也很非凡。对B的享有实例,instanceof为A和B都回到true。ECMAScript的弱类型世界中,那是相当有用的工具,可是使用对象冒充时不可能动用它。例如:

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图