1、原型链继承
function Parent(){
this.name = 'cegz';
}
Parent.prototype.getName = function(){
console.log(this.name);
}
function Child(){}
Child.prototype = new Child();
let child = new Child();
child.getName() // cegz
问题：
- 1、引用类型的属性被所有实例共享：例如
function Parent(){
this.animal = ['cat','fish'];
}
function Child(){}
Child.prototype = new Parent();
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.animal); // ['car','fish','dog']
console.log(child2.animal); // ['car','fish','dog']
- 2、在创建 Child 的实例时，不能向Parent传参
2、借用构造函数(经典继承)
function Parent(){
this.animal = ['cat','fish'];
}
function Child(){
Parent.call(this);
}
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.animal); // ['cat','fish','dog']
console.log(child2.animal); // ['cat','fish']
优点：
1、避免了引用类型属性被所有实例共享
2、可以在Child中向Parent传参
function Parent(name){
this.name = name;
}
function Child(name){
Parent.call(this,name);
}
let child1 = new Child('cyl');
let child2 = new Child('cegz');
console.log(child1.name); // cyl
console.log(child2.name); // cegz
缺点：
1、方法都在构造函数中定义，，每次创建实例都会创建一次方法
2、获取不到原型上的成员属性
3、组合继承(原型链继承和经典继承)
function Parent(name){
this.name = name;
this.animal = ['fish','cat','dog'];
}
Parent.prototype.getName = function(){
console.log(this.name);
}
function Child(name,age){
Parent.call(this,name);
this.age = age;
}
Child.prototype = new Parent();
Child.prototype.constructor = Child;
let child1 = new Child('cyl',18);
let child2 = new Child('cegz',20);
child1.animal.push('duck');
child1.getName(); // cyl
child2.getName(); // cegz
console.log(child1.name); // cyl
console.log(child1.age); // 18
console.log(child1.animal); // ["fish", "cat", "dog", "duck"]
console.log(child2.name); // cegz
console.log(child2.age); // 20
console.log(child2.animal); // ["fish", "cat", "dog"]
优点：结合原型链和构造函数的优点，最常用的继承方式
缺点：会调用两次父构造函数，每new一次，都会执行一次new 的构造函数，我们打印child1对象，会发现Child.prototype 和 child1 都有一个属性为animal
Child.prototype = new Parent(); // 第一次调用
let child1 = new Child('cyl',18); // 第二次调用
4、原型式继承
function Parent(){
this.name = 'cyl'
}
Parent.prototype.animal = ['fish','cat'];
function Child(){}
Child.prototype = Parent.prototype;
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.name,child1.animal); //undefined ["fish", "cat", "dog"]
console.log(child2.name,child2.animal); //undefined ["fish", "cat", "dog"]
缺点：
1、原型上的属性如果是引用类型，该属性会在实例之间实现共享
2、只能继承原型对象成员，不能继承父构造函数实例成员
5、寄生式继承
创建一个仅用于封装继承过程的函数，该函数在内部以某种形式来做增强对象，最后返回对象。
function createObj(o){
let clone = Object.create(o); //调用函数创建一个新对象
clone.sayName = function(){ // 以某种方式来增强该对象
console.log('hi');
}
return clone // 返回该对象
}
缺点：跟借用构造函数一样，每次创建对象都会创建一次方法
6、寄生组合式继承
组合继承最大的缺点是会调用两次父构造函数，如果不使用Child.prototype = new Parent()，而是间接的让Child.prototype访问到Parent.prototype,并且避免实例对象child和构造函数原型Child.prototype拥有重复的属性
看看如何实现：
function Parent(name){
this.name = name;
this.animal = ['cat','fish','dog'];
}
Parent.prototype.getName = function(){
console.log(this.name);
}
function Child(name,age){
Parent.call(this,name);
this.age = age;
}
//关键的三步
let F = function(){};
F.prototype = Parent.prototype;
Child.prototype = new F();
let child = new Child('cyl',18);
console.log(child); // 只有child实例上才会有Parent继承的animal
最后封装一个这个继承方法：
function object(o){
function F() {}
F.prototype = 0;
return new F();
}
function prototype(child,parent){
let prototype = object(child,parent);
prototype.constructor = child;
child.prototype = prototype;
}
//使用
prototype(Child,Parent);
完整实例：
function Parent(name){
this.name = name;
this.animal = ['cat','fish'];
}
Parent.prototype.getName = function(){
console.log(this.name);
}
function Child(name,age){
Parent.call(this,name);
this.age = age;
}
function object(o){
function F(){};
F.prototype = o;
return new F();
}
function prototype(child,parent){
var prototype = object(parent.prototype);
prototype.constructor = child;
child.prototype = prototype;
}
prototype(Child,Parent);
let child1 = new Child('cyl',18);
let child2 = new Child('cegz',20);
child1.getName(); // 'cyl'
child2.getName(); // 'cegz'
child1.animal.push('dog');
console.log(child1.animal); // ["cat", "fish", "dog"]
console.log(child2.animal); // ["cat", "fish"]
这种方式的高效率体现它只调用了一次Parent 构造函数，并且避免了在Parent.prototype上面创建不必要、多余的属性，所以寄生组合继承是引用类型最理想的继承范式。
