JS中常用的继承

在日常的开发中，经常会封装一些方法用作公共的方法。此后在定义某一个子类方法，需要继承父类方法的一下函数、变量等，此时 就用到了继承.。个人见解，欢迎大家指正

1、原型时继承，主要属性propotype

缺点：继承单一，所有新实例都会共享父类实例的属性（一个实例修改了原型属性，另一个实例的原型属性也会被修改）

 

function Animal(){    
    this.name = "Animal";    
     this.showName = function(){    
     alert(this.name);    
    }    
}

function sub(){
    this.name = "Cat"
}

sub.prototype = new Animal()
var s = new sub()

console.log(s.showName()) // Cat

2、构造函数继承，主要方法call()

缺点：只能继承父类构造函数的属性，无法实现构造函数的复用

function Animal(name){    
    this.name = name;    
    this.showName = function(){    
    alert(this.name);    
    }    
} 

function Cat() {
  Animal.call(this,'Cat')  
}

var s = new Cat()

console.log(s.showName()) // Cat

3、组合继承，将前边俩种方法合并

缺点：调用了两次父类构造函数

function Animal(name){    
    this.name = name;    
    this.showName = function(){    
    alert(this.name);    
    }    
} 

function Cat(name) {
  Animal.call(this,name)  
}

Cat.propotype = new Animal()
var s = new Cat("Dog")

console.log(s.showName()) // Dog

4、原型式继承

缺点：所有实例都会继承原型上的属性

function Animal(name){    
    this.name = name;    
    this.showName = function(){    
    alert(this.name);    
    }    
} 

function Cat(obj) {
    function s(){}
    s.prototype = obj
    return new s()
}

var s = new Animal("Dog")
var s1 = Cat(s)

console.log(s1.showName()) // Dog

5、寄生组合式继承

 寄生是指在函数内返回对象，然后去调用；组合是指函数的原型等于另一个实例，函数中可使用call()引入另一个构造函数

function Animal(name){    
    this.name = name;    
    this.showName = function(){    
    alert(this.name);    
    }    
} 

function Cat(obj) {
    function S(){}
    S.prototype = obj
    return new s()
}

// Cat是S实例的一种表示法
// s实例（S实例）的原型继承了父类函数的原型
var s = Cat(Animal.prototype) 

// 组合，继承父类构造函数的属性
function Dog(name) {
    Animal.call(this,name)
}

// 继承s实例
Dog.prototype = s  
// 必须修复实例
s.constructor = Dog

var s1 = new Dog("Dog")

console.log(s1.showName())

参考文章：https://www.cnblogs.com/ranyonsue/p/11201730.html