Simplemente podemos dividirnos en los siguientes métodos de herencia :
- Herencia de la cadena de prototipos
- Herencia del constructor
- Herencia combinatoria
- Herencia de combinación de parásitos / herencia de combinación de parásitos mejorada
- Herencia de clases
La siguiente A representa al padre y B representa al hijo
Veamos
primero la herencia de la cadena del prototipo y el código primero
function A(name,age){
this.name = name;
this.arr = [];
this.age = age;
this.sing = function(){
return '我会唱歌、我会跳舞。'
}
}
function B(run){
this.run = run
}
B.prototype = new A('zjq',18)
console.log(new B()._proto_ === A.construct)
let a = new B('123')
let b = new B('456')
a.arr.push('1')
console.log(b.arr) //['1']
B se ha integrado completamente en las propiedades y métodos de A, pero hay una desventaja de que cuando instanciamos dos B, agregamos un elemento al primer arr, y el segundo objeto instanciado también cambiará en consecuencia. Tanto a como b tienen un elemento nuevo agregado a arr. El método pasa a ser compartido, no privado para la instancia. (Tipo de referencia)
Código de herencia del constructor
function A(name,age){
this.name = name;
this.age = age;
this.arr =[];
this.sing = function(){
return '我会唱歌、我会跳舞。'
}
}
function B(run){
this.run = run
A.call(this,'zjq',this.run) //父级的属性和方法称为子级的私有属性和方法 子级可以向父级传参
}
let Bobj = new B('runing')
console.log(Bobj)
console.log(Bobj.sing())
let a = new B('123')
let b = new B('456')
a.arr.push('1')
console.log(b.arr) //[]
Aunque la herencia del constructor puede usar los métodos y propiedades de A, no está relacionada con la herencia. No hay información sobre A en su _proto_. Convierte las propiedades y métodos de A en sus propias propiedades y métodos. Para crear una instancia de una subclase, puede pasar parámetros al constructor de la clase principal. Resolvió el problema de que el método se compartiera y se volviera privado para la instancia.
Herencia combinada
en código
function A(name, age) {
this.name = name;
this.age = age;
this.arr=[]
}
A.prototype.sing = function () {
return '我会唱歌、我会跳舞。' + this.name + this.age
}
function B(run) {
this.run = run
A.call(this, 'zjq', this.run) //父级的属性和方法称为子级的私有属性和方法 子级可以向父级传参
}
B.prototype = new A()
let brr = new B('参数')
let a = new B('123')
let b = new B('456')
a.arr.push('1')
console.log(b.arr) //[]
console.log(brr)
console.log(brr.sing())
console.log(brr.age)
Combinando las ventajas de la herencia de la cadena de prototipos y la herencia del constructor prestada, heredar las propiedades y los métodos de A también puede pasar sus propios parámetros a A. Se resolvió el problema de que el método se compartiera y se volviera privado para la instancia, pero se llamó dos veces al constructor A.
Código de herencia de combinación parasitaria
function A(name, age) {
this.name = name;
this.age = age;
this.arr = []
}
A.prototype.sing = function () {
return '我会唱歌、我会跳舞。' + this.name + this.age
}
function B(run) {
this.run = run
A.call(this, 'zjq', this.run)
}
B.prototype = A.prototype
// let b= new B('123')
// console.log(b)
B.prototype.sing = function () {
return 'xxx'
}
let a = new B('123')
let b = new B('456')
a.arr.push('1')
console.log(b.arr) //[]
console.log(new A().sing()) //变成了xxx 而不是 return '我会唱歌、我会跳舞。' + this.name + this.age
Resuelve el problema de que el método se comparte y se vuelve privado para la instancia, pero hay otro problema pendiente: B puede cambiar cosas en la cadena de prototipos y A y B comparten la cadena de prototipos.
Herencia de combinación de parásitos mejorada
function A(name, age) {
this.name = name;
this.age = age;
}
A.prototype.sing = function () {
return '我会唱歌、我会跳舞。' + this.name + this.age
}
function B(run) {
this.run = run
A.call(this, 'zjq', this.run)
}
function f(){
}
f.prototype = A.prototype
B.prototype = new f()
let b= new B('123')
console.log(b)
B.prototype.sing = function(){
return 'xxx'
}
console.log(new A().sing()) //return '我会唱歌、我会跳舞。' + this.name + this.age
Resuelto el problema de la cadena de prototipos compartidos. Final perfecto.
Herencia de clases
en código
class A {
//父级构造函数
constructor(name) {
this.name = name;
}
sing() {
return this.name + 'xxx'
}
}
class B extends A {
//子级继承父级
constructor(name,age) {
super(name) 调用实现父类的构造函数 并传递参数
this.age = age
}
}
let b = new B(12333,222) //实例化子级
console.log(b)
console.log(b.sing()) //return this.name + 'xxx'
Si hay algún problema con el contenido anterior, comente a tiempo.