数码资讯
对Javaｓｃｒｉｐｔ原型链和继承的深入理解
在这篇文章中，介绍了原型的概念，理解之间的关系的构造函数，在Javaｓｃｒｉｐｔ中，原型对象三例好闺蜜：每个构造函数的原型对象的守护者，心里面也存在一个构造函数的原型对象的位置，两情相悦，它就像是一个原型实例对象，她还保留在一个原型对象位置的心。 Javaｓｃｒｉｐｔ本身不是面向对象的语言，而是基于
选购提示
关注价格、性能、续航、售后和真实使用场景，理性比较后再下单。
在这篇文章中，介绍了原型的概念，理解之间的关系的构造函数，在Javaｓｃｒｉｐｔ中，原型对象三例好闺蜜：每个构造函数的原型对象的守护者，心里面也存在一个构造函数的原型对象的位置，两情相悦，它就像是一个原型实例对象，她还保留在一个原型对象位置的心。
Javaｓｃｒｉｐｔ本身不是面向对象的语言，而是基于对象的语言，使用的人先其他面向对象的语言，有些不适应，因为没有概念类，或不区分类和实例之间，但别指望父类的子类，等等。，这堆Javaｓｃｒｉｐｔ中的对象是什么
幸运的是，Javaｓｃｒｉｐｔ在设计开始时提供了继承的方法，现在我们理解了原型链的概念，然后再理解继承。
原型链
我们知道原型有一个指向构造函数的指针。如果我们让子类的原型对象等于另一个实例，新的SuperClass（）在这一点上，子类的原型对象包含一个指向父类和父类的原型，原型也包含一个指针指向基类构造函数。这样，就形成了一个原型链。
具体代码如下：
函数的SuperClass（）{
this.name =女性
}
superclass.prototype.saywhat =函数（）{
返回this.name +：我是一个女孩`！；
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
subclass.prototype.subsaywhat =函数（）{
返回this.subname +：我` M一个漂亮的女孩；
}
var =新子类（）；
console.log（sub.saywhat（））； / /女：我是一个女孩`！
利用原型链实现继承
通过上面的代码可以在子类继承了父类出现的属性和方法，继承被分配到原型对象的子类的超类的实例对象的子类实现，原型是这样的一个实例的类覆盖，有它的所有属性和方法，也有一点父类原型对象指针。
在使用原型链进行继承时，我们需要注意一些地方：
注意构造函数的变化后，继承。子父类构造函数在这里指出，由于子类指向父类的原型的原型。当我们理解原型链，我们不应该忽视的默认对象结束，这就是为什么我们可以用物体在所有对象的ToString。
当原型链用于实现继承时，我们不能使用文字数量来定义原型方法，因为它将重写原型对象。
函数的SuperClass（）{
this.name =女性
}
superclass.prototype.saywhat =函数（）{
返回this.name +：我是一个女孩`！；
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
subclass.prototype = { / /原型对象覆盖，因为不能继承父类的属性和方法
subsaywhat：函数（）{
返回this.subname +：我` M一个漂亮的女孩；
}
}
var =新子类（）；
console.log（sub.saywhat（））； / /列表的定义不是一个函数
实例共享的问题。在原型和前面的构造函数中，我们已经介绍了原型包含引用类型的属性都是共享的，同时，我们继承了原型将引用类型的属性类的原型，当我们修改原型继承父类引用类型的属性，因为原型实例将影响所有其他产业，这不仅是对资源的浪费，我们都不愿意看到的现象：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
VaR SUB1 =新的子类（）；
sub1.name =人；
sub1.bra.push（C）；
console.log（SUB1。名称）； / /人
console.log（SUB1。胸罩）； / / {
VaR子=新的子类（）；
console.log（SUB1。名称）； / /女人
console.log（SUB2。胸罩）； / / {
注：这是一个元素添加到数组的所有实例，都继承了SuperClass会受到影响，但如果修改name属性，它不会影响到其他的情况，因为数组是引用类型，并命名为基本型。
如何解决实例共享的问题我们下去看看吧。
经典继承（构造函数偷窃）
我们介绍了对象原型的定义很少单独使用，在实际开发中我们很少使用原型链，针对引用类型的共享问题，Javaｓｃｒｉｐｔ开发者介绍了传承的经典模式（也称为继承，使用构造函数）实现是很简单的被称为子类型构造函数超类的构造函数。我们需要使用电话（）（）（）或应用提供的Javaｓｃｒｉｐｔ函数，并让我们在例子看看：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
函数子类（）{
this.subname =你姐姐；
超类 / /会给构造函数实现继承的范围
superclass.call（本）；
}
VaR SUB1 =新的子类（）；
sub1.bra.push（C）；
console.log（SUB1。胸罩）； / / {
VaR子=新的子类（）；
console.log（SUB2。胸罩）； / / {
superclass.call（本）；这句话的意思是父类的构造函数中实例的初始化工作（背景）环境下的子类，所以每个实例具有其自己的文胸属性复制，而且不互相影响。
然而，这样的实现方式仍不完善，因为构造函数的介绍，所以我们也面临着在构造函数中存在的问题，说：如果在构造函数的定义方法，所以没有一个实例存在一个单独的函数参考，我们的目的是想分享这个方法，但是，我们定义的超级型原型法在子类型的实例是无法打电话的：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
SuperClass.prototype.sayWhat = function () {
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）；
}
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /列表的定义不是一个函数
如果您已经阅读了关于原型对象和构造函数的前一篇文章，您可能知道这个问题的答案。即遵循第一部分的套路，采用组合拳。
组合继承
结合原型链和构造函数继承是各自的专业优势，结合继承，仅仅是使用原型链继承的属性和方法，借用构造函数来实现继承实例属性的使用，从而解决实例属性共享的问题，也让父类的属性和方法的继承：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
superclass.prototype.saywhat =函数（）{
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）； / /第二呼叫SuperClass
}
subclass.prototype =新（父类）； / /首先打电话给SuperClass
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /你好
结合我们继承的实际发展是最常见的继承方式，这可以满足你人们的实际发展需要，但却是永无止境的追求完美，所以一定有人在这种模式下：这种模式被称为鲤鱼两倍超类型构造函数！两个耶稣…你做到了，这是比表演大一百倍的损失吗
最有力的反驳是提出解决方案，但开发人员已经找到了解决这个问题的最佳方法。
寄生组合继承
在这种传承方式的介绍，我们首先了解寄生构造函数构造函数的概念，类似于前面提到的寄生植物模型，该方法定义一个公共函数，这个函数是用来创建对象，该函数返回后完成创建的对象，如一个构造函数，但构造函数没有返回值：
函数GF（名称，胸罩）{
var obj =新的对象（）；
obj.name =名称；
obj.bra =胸罩；
obj.saywhat =函数（）{
console.log（这个名字）；
}
返回对象；
}
VaR GF1 =新的GF（兵兵
console.log（gf1.saywhat（））； / /冰冰
对寄生型和寄生型构造函数进行继承相似，创建一个不依赖于具体类型的工厂函数，继承过程来处理对象，然后返回继承对象实例，幸运的是需要我们自己实现，道格拉斯（道格拉斯）已经为我们提供了一条途径：
函数对象（obj）{
函数（f）{ }
f.prototype = obj；
返回新的f（）；
}
父= { { var
名称：兵兵
文胸：C++
}
VaR的子类对象（父类）=；
console.log（子类名称）； / /冰冰
公共函数中提供了一个简单的构造函数。然后，发送给对象的实例被分配给构造函数的原型对象。最后，它返回构造函数的实例。这很简单，但效果很好，不是吗这种方法被称为后代的原型继承，并在原型的基础上实现寄生继承，通过增强对象的自定义属性：
功能buildobj（obj）{
var o =对象（目标）；
o.saywhat =函数（）{
console.log（你好）；
}
回来啊；
}
父= { { var
名称：兵兵
文胸：C++
}
VaR GF = buildobj（父类）；
Gf.sayWhat（）； / /你好
寄生继承面临多路复用功能的原型同样的问题，于是人们开始拼积木，出生，寄生组合继承，目的是为了解决特定的亚型的原型称为母型的建设者，同时，最大限度的重用功能。以下基本实现如下：
对于两个构造函数参数
功能inheritobj（子，SUP）{
例如，继承，获取超级类型的副本。
对象（原型）；
构造函数属性重新指定原始实例
proto.constructor =子；
将创建对象分配给子类型原型。
sub.prototype =原；
}
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
superclass.prototype.saywhat =函数（）{
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）；
}
InheritObj（子、SuperClass）；
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /你好
这种方式避免了两个调用超类型，并可节省不必要的属性subclass.prototype。同时，它也保留了原型链，它真正结束了继承的旅程。这种实现方式也成为实现继承的最理想方式，人们对Javaｓｃｒｉｐｔ继承的争论还在继续。有些人崇尚OO。有人反对在Javaｓｃｒｉｐｔ中做额外的努力来实现OO的特性。至少，他知道一些关于它的事。
Javaｓｃｒｉｐｔ本身不是面向对象的语言，而是基于对象的语言，使用的人先其他面向对象的语言，有些不适应，因为没有概念类，或不区分类和实例之间，但别指望父类的子类，等等。，这堆Javaｓｃｒｉｐｔ中的对象是什么
幸运的是，Javaｓｃｒｉｐｔ在设计开始时提供了继承的方法，现在我们理解了原型链的概念，然后再理解继承。
原型链
我们知道原型有一个指向构造函数的指针。如果我们让子类的原型对象等于另一个实例，新的SuperClass（）在这一点上，子类的原型对象包含一个指向父类和父类的原型，原型也包含一个指针指向基类构造函数。这样，就形成了一个原型链。
具体代码如下：
函数的SuperClass（）{
this.name =女性
}
superclass.prototype.saywhat =函数（）{
返回this.name +：我是一个女孩`！；
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
subclass.prototype.subsaywhat =函数（）{
返回this.subname +：我` M一个漂亮的女孩；
}
var =新子类（）；
console.log（sub.saywhat（））； / /女：我是一个女孩`！
利用原型链实现继承
通过上面的代码可以在子类继承了父类出现的属性和方法，继承被分配到原型对象的子类的超类的实例对象的子类实现，原型是这样的一个实例的类覆盖，有它的所有属性和方法，也有一点父类原型对象指针。
在使用原型链进行继承时，我们需要注意一些地方：
注意构造函数的变化后，继承。子父类构造函数在这里指出，由于子类指向父类的原型的原型。当我们理解原型链，我们不应该忽视的默认对象结束，这就是为什么我们可以用物体在所有对象的ToString。
当原型链用于实现继承时，我们不能使用文字数量来定义原型方法，因为它将重写原型对象。
函数的SuperClass（）{
this.name =女性
}
superclass.prototype.saywhat =函数（）{
返回this.name +：我是一个女孩`！；
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
subclass.prototype = { / /原型对象覆盖，因为不能继承父类的属性和方法
subsaywhat：函数（）{
返回this.subname +：我` M一个漂亮的女孩；
}
}
var =新子类（）；
console.log（sub.saywhat（））； / /列表的定义不是一个函数
实例共享的问题。在原型和前面的构造函数中，我们已经介绍了原型包含引用类型的属性都是共享的，同时，我们继承了原型将引用类型的属性类的原型，当我们修改原型继承父类引用类型的属性，因为原型实例将影响所有其他产业，这不仅是对资源的浪费，我们都不愿意看到的现象：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
函数子类（）{
this.subname =你姐姐；
}
subclass.prototype =新的父类（）；
VaR SUB1 =新的子类（）；
sub1.name =人；
sub1.bra.push（C）；
console.log（SUB1。名称）； / /人
console.log（SUB1。胸罩）； / / {
VaR子=新的子类（）；
console.log（SUB1。名称）； / /女人
console.log（SUB2。胸罩）； / / {
注：这是一个元素添加到数组的所有实例，都继承了SuperClass会受到影响，但如果修改name属性，它不会影响到其他的情况，因为数组是引用类型，并命名为基本型。
如何解决实例共享的问题我们下去看看吧。
经典继承（构造函数偷窃）
我们介绍了对象原型的定义很少单独使用，在实际开发中我们很少使用原型链，针对引用类型的共享问题，Javaｓｃｒｉｐｔ开发者介绍了传承的经典模式（也称为继承，使用构造函数）实现是很简单的被称为子类型构造函数超类的构造函数。我们需要使用电话（）（）（）或应用提供的Javaｓｃｒｉｐｔ函数，并让我们在例子看看：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
函数子类（）{
this.subname =你姐姐；
超类 / /会给构造函数实现继承的范围
superclass.call（本）；
}
VaR SUB1 =新的子类（）；
sub1.bra.push（C）；
console.log（SUB1。胸罩）； / / {
VaR子=新的子类（）；
console.log（SUB2。胸罩）； / / {
superclass.call（本）；这句话的意思是父类的构造函数中实例的初始化工作（背景）环境下的子类，所以每个实例具有其自己的文胸属性复制，而且不互相影响。
然而，这样的实现方式仍不完善，因为构造函数的介绍，所以我们也面临着在构造函数中存在的问题，说：如果在构造函数的定义方法，所以没有一个实例存在一个单独的函数参考，我们的目的是想分享这个方法，但是，我们定义的超级型原型法在子类型的实例是无法打电话的：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
SuperClass.prototype.sayWhat = function () {
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）；
}
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /列表的定义不是一个函数
如果您已经阅读了关于原型对象和构造函数的前一篇文章，您可能知道这个问题的答案。即遵循第一部分的套路，采用组合拳。
组合继承
结合原型链和构造函数继承是各自的专业优势，结合继承，仅仅是使用原型链继承的属性和方法，借用构造函数来实现继承实例属性的使用，从而解决实例属性共享的问题，也让父类的属性和方法的继承：
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
superclass.prototype.saywhat =函数（）{
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）； / /第二呼叫SuperClass
}
subclass.prototype =新（父类）； / /首先打电话给SuperClass
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /你好
结合我们继承的实际发展是最常见的继承方式，这可以满足你人们的实际发展需要，但却是永无止境的追求完美，所以一定有人在这种模式下：这种模式被称为鲤鱼两倍超类型构造函数！两个耶稣…你做到了，这是比表演大一百倍的损失吗
最有力的反驳是提出解决方案，但开发人员已经找到了解决这个问题的最佳方法。
寄生组合继承
在这种传承方式的介绍，我们首先了解寄生构造函数构造函数的概念，类似于前面提到的寄生植物模型，该方法定义一个公共函数，这个函数是用来创建对象，该函数返回后完成创建的对象，如一个构造函数，但构造函数没有返回值：
函数GF（名称，胸罩）{
var obj =新的对象（）；
obj.name =名称；
obj.bra =胸罩；
obj.saywhat =函数（）{
console.log（这个名字）；
}
返回对象；
}
VaR GF1 =新的GF（兵兵
console.log（gf1.saywhat（））； / /冰冰
对寄生型和寄生型构造函数进行继承相似，创建一个不依赖于具体类型的工厂函数，继承过程来处理对象，然后返回继承对象实例，幸运的是需要我们自己实现，道格拉斯（道格拉斯）已经为我们提供了一条途径：
函数对象（obj）{
函数（f）{ }
f.prototype = obj；
返回新的f（）；
}
父= { { var
名称：兵兵
文胸：C++
}
VaR的子类对象（父类）=；
console.log（子类名称）； / /冰冰
公共函数中提供了一个简单的构造函数。然后，发送给对象的实例被分配给构造函数的原型对象。最后，它返回构造函数的实例。这很简单，但效果很好，不是吗这种方法被称为后代的原型继承，并在原型的基础上实现寄生继承，通过增强对象的自定义属性：
功能buildobj（obj）{
var o =对象（目标）；
o.saywhat =函数（）{
console.log（你好）；
}
回来啊；
}
父= { { var
名称：兵兵
文胸：C++
}
VaR GF = buildobj（父类）；
Gf.sayWhat（）； / /你好
寄生继承面临多路复用功能的原型同样的问题，于是人们开始拼积木，出生，寄生组合继承，目的是为了解决特定的亚型的原型称为母型的建设者，同时，最大限度的重用功能。以下基本实现如下：
对于两个构造函数参数
功能inheritobj（子，SUP）{
例如，继承，获取超级类型的副本。
对象（原型）；
构造函数属性重新指定原始实例
proto.constructor =子；
将创建对象分配给子类型原型。
sub.prototype =原；
}
函数的SuperClass（）{
this.name =女性；
this.bra = {
}
superclass.prototype.saywhat =函数（）{
console.log（你好）；
}
函数子类（）{
this.subname =你姐姐；
superclass.call（本）；
}
InheritObj（子、SuperClass）；
VaR SUB1 =新的子类（）；
console.log（sub1.saywhat（））； / /你好
这种方式避免了两个调用超类型，并可节省不必要的属性subclass.prototype。同时，它也保留了原型链，它真正结束了继承的旅程。这种实现方式也成为实现继承的最理想方式，人们对Javaｓｃｒｉｐｔ继承的争论还在继续。有些人崇尚OO。有人反对在Javaｓｃｒｉｐｔ中做额外的努力来实现OO的特性。至少，他知道一些关于它的事。
声明：本文内容用于数码产品信息整理与选购参考，具体价格、库存、售后政策以官方渠道和电商页面实时信息为准。