En primer lugar, vamos a hablar de lo que se hereda?
En términos simples, es para hacer un ningún objeto hereda algunas de las propiedades y métodos de tener propiedades y métodos de ambas propiedades tienen un método del objeto.
Que la herencia se divide, lo que hace? Voy a explicar a usted algunas comunes heredó.
1. objeto prototipo heredado
function Parent(){
this.name = "zhangshan";
}
Parent.prototype.show = function(){
console.log("111");
}
function Child(){
}
// 浅拷贝
Child.prototype = Parent.prototype;
var t = new Parent();
t.show();//111
console.log(t.name);//zhangshan
var f = new Child();
f.show();//111
console.log(f.name);//undefined
Lo anterior es el resultado de la forma en que usamos poco profunda copia heredada, pero si si mismo niño tiene una manera de mostrarla? Tanto si se tendrá que cubrirlo?
function Parent(){
this.name = "zhangshan";
}
Parent.prototype.show = function(){
console.log("111");
}
function Child(){
}
// 浅拷贝
Child.prototype = Parent.prototype;
//
Child.prototype.show = function(){
console.log("123");
}
var t = new Parent();
t.show();//123
console.log(t.name);//zhangshan
var f = new Child();
f.show();//123
console.log(f.name);//undefined
Los resultados, como se predijo, ya que el uso de la copia superficial, pero cuando los prototipos método Niño muestran que cubre un espectáculo prototipo método de Padres, por lo que muestran el valor del método de salida se ha convertido en el Padre 123; cómo se puede solucionar? Podemos hacer una copia profunda de su manera de ser descubierto.
function Parent(){
this.name = "zhangshan";
}
Parent.prototype.show = function(){
console.log("111");
}
function Child(){
}
// 深拷贝:不会被覆盖
for(var i in Parent.prototype){
Child.prototype[i] = Parent.prototype[i];
}
//
Child.prototype.show = function(){
console.log("123");
}
var t = new Parent();
t.show();//111
console.log(t.name);//zhangshan
var f = new Child();
f.show();//123
console.log(f.name);//undefined
En resumen: nuestro prototipo objeto de herencia 1. simple, conveniente, fácil de operar. 2. Sin embargo, el cuerpo del prototipo sólo puede heredar los métodos y propiedades no pueden heredar los métodos y propiedades en el constructor.
2. cadena de prototipo para heredar
function Parent(){
this.name = "zhangshan"
}
Parent.prototype.show = function(){
console.log("哈哈哈")
}
function Child(){
}
Child.prototype = new Parent();
// Parent的实例
var f = new Parent();
f.show();///哈哈哈
console.log(f.name);///zhangshan
// Child的实例
var t = new Child();
t.show();///哈哈哈
console.log(t.name);//zhangshan
Obviamente utilizamos prototipo de solución de herencia cadena perfecta para el constructor de objetos prototipo no se puede heredar las propiedades y métodos de defectos, pero la cadena de prototipo para heredar si hay desventajas? Me gustaría que todo el mundo vistazo a un ejemplo:
function Parent(n){
this.name = n;
}
Parent.prototype.show = function(){
console.log("哈哈哈")
}
function Child(n){
}
Child.prototype = new Parent("lisi");
// Parent的实例
var f = new Parent();
f.show();///哈哈哈
console.log(f.name);///undefined
// Child的实例
var t = new Child();
t.show();///哈哈哈
console.log(t.name);//lisi
Vale la pena el tiempo cuando usamos el constructor paso de parámetros manera de los atributos de entrada para padres, nos encontramos con que no es posible, los padres nombre de atributo no está definido, esto también muestra que nuestra cadena de prototipo para heredar 1. más sencilla, cómoda fácil de operar. 2. Sólo se puede heredada cuerpo prototipo de métodos y propiedades, pero también heredó métodos constructores y propiedades. 3. participación de las masas Sin embargo, conveniente.
3. La herencia constructor
function Parent(s){
this.skill = s;
}
Parent.prototype.show = function(){
console.log(this.skill);
}
function Child(n){
// 利用this的改变
// 在Child中执行Parent的同时，修改this指向，为Child的this
// 因为Child将来被new执行，Child中的this，指向将来Child的实例
Parent.call(this,n);
}
var p = new Parent("zhangshan");
console.log(p.skill);//zhangshan
p.show();//zhangshan
var c = new Child("lisi");
console.log(c.skill);//lisi
c.show();//报错
Por el ejemplo anterior podemos ver constructor heredado: pueden heredar propiedad o método dentro del constructor puede propiedad o método no hereda cuerpo prototipo.
4. Mezcla de herencia
function Parent(s){
this.skill = s;
}
Parent.prototype.show = function(){
console.log(this.skill);
}
function Child(n){
Parent.call(this,n);
}
for(var i in Parent.prototype){
Child.prototype[i] = Parent.prototype[i];
}
Child.prototype.show = function(){
console.log("wangwu");
}
var p = new Parent("zhangshan");
p.show();//zhangshan
var c = new Child("lisi");
c.show();//wangwu
console.log(c.skill);//lisi
La herencia mixta: Hereditaria herencia de prototipo constructor +, y sus características son las siguientes: 1. un poco complicado. 2. Usted puede heredar constructores, pero también puede ser heredada prototipo. 3. fácil de pasar parámetros. 4. constructor puede ser la herencia múltiple. Pero ¿por qué no se menciona la cadena de prototipo para heredar, porque todavía hay riesgos cadena de prototipo a los parámetros de heredar, por lo que por el momento no se aplica.
herencia 5.class
class Parent{
constructor(s){
this.skill = s;
}
show(){
console.log(this.skill);
}
}
class Child extends Parent{
constructor(n){
super(n);
}
}
var p = new Parent("zhangshan");
p.show();//zhangshan
var c = new Child("lisi");
c.show();//lisi
Cuando heredamos ES6 clase, nos pareció que era una forma muy conveniente para heredar, se basan principalmente se extiende y super. Pero sus obras: a heredar argumento del constructor + la cadena de prototipo para heredar.
