1.原型链继承
核心: 将父类的实例作为子类的原型
缺点:
1.要想为子类新增原型属性和方法，必须要在new Parent()这样的语句之后执行
2.无法实现多继承。
3.来自父类原型对象的所有属性被所有实例共享
4.创建子类实例时，无法向父类构造函数传参。
function Parent(age) {
this.age = age;
};
Parent.prototype.friends = ['a', 'b'];
Parent.prototype.getAge = function () { //对原型进行扩展
return this.age;
};
function Child(sex) {
this.sex = sex;
};
Child.prototype = new Parent(29); //这一句是关键 //通过构造器函数创建出一个新对象，把老对象的东西都拿过来。
Child.prototype.getSex = function () {
return this.sex;
};
// Child.prototype.getAge = function () { //可以重写从父类继承来的方法,会优先调用自己的。
// console.log(222);
// };
var result = new Child('male');
var temp = new Child('female');
temp.friends.push('c');
console.log(result.friends); // ['a', 'b', 'c']
console.log(result.getSex()); // output: male //调用了从 Parent 原型中继承来的方法(继承到了当前对象的原型中)
console.log(result.getAge()); // output: 29 //调用了从 Child 原型中扩展来的方法
2.构造继承
基本思想: 借用构造函数的基本思想就是利用call或者apply把父类中通过this指定的属性和方法复制(借用)到子类创建的实例中.
因为this对象是在运行时基于函数的执行环境绑定的.也就是说,在全局中, this等于window,而当函数被作为某个对象的方法调用时, this等于那个对象.
call、apply方法可讲一个函数的底箱上下文从初始的上下文改变为由 thisObj指定的新对象.
所以,这个借用构造函数就是, new对象的时候(new创建的时候, this指向创建的这个实例), 创建了一个新的实例对象,
并且执行Child里面的代码, 而Child里面用call调用了Parent,也就是说 把this指向改成了指向新的实例,
所以就会把Child里面的this县官属性和方法复制到新的实例上, 而不是赋值到Parent上面,所以所有实例中就拥有了父类定义的这些this的属性和方法.
因为属性是绑定到this上面的, 所以调用的时候才赋到相应的实例中, 各个实例的值就不会互相影响了.
核心: 使用父类构造函数来增强子类实例, 等于是赋值父类的实例属性给子类(没用到原型);
缺点: 方法都在构造函数中定义, 只能继承父类的实例属性和方法, 不能继承原型属性/方法, 无法实现函数复用, 每个子类都有父类实例函数的副本, 影响性能
function Parent(age){
this.age = age;
this.friends = ['a', 'b'];
this.getAge = function() {
return this.age;
}
}
Parent.prototype.consoleLog = function () { // 对原型进行扩展的方法就无法复用了
console.log('这是原型方法');
}
function Child(sex) {
Parent.call(this, '29');
this.sex = sex;
}
var result = new Child('male');
console.log(result.age); // 29
console.log(result.friends); // [a, b]
console.log(result.getAge()); // 29
console.log(result.sex); // male
console.log(result.consoleLog()); // ❌ TypeError: result.consoleLog is not a function
3.组合继承
组合继承（所有的实例都能拥有自己的属性，并且可以使用相同的方法，组合继承避免了原型链和借用构造函数的缺陷，结合了两个的优点，是最常用的继承方式）
核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后再通过将父类实例作为子类原型，实现函数复用
缺点：调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）
function Parent(age) {
this.age = age;
this.friends = ['a', 'b'];
};
Person.prototype.getAge = function () {
return this.age;
};
function Child(sex) {
Parent.call(this, '29'); //这一步很关键
this.sex = sex;
};
Child.prototype = new Parent('29'); //这一步也很关键
var result = new Child('male');
console.log(result.age); // 29
result.friends.push("c");
console.log(result.friends); // ['a','b','c']
console.log(result.getAge()); // 29
console.log(result.sex); // male
var result1 = new Child('female'); //通过借用构造函数都有自己的属性，通过原型享用公共的方法
console.log(result1.sex); //female
console.log(result1.friends); //['a','b']
4.寄生组合继承
核心：通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点
缺点：堪称完美，但实现较为复杂
function Parent(age) {
this.age = age;
this.friends = ['a','b'];
}
Parent.prototype.getAge = function () {
return this.age;
};
function Child(sex) {
Parent.call(this, '29');
this.sex = sex;
}
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;
var result = new Child('male');
console.log(result.age);
console.log(result.friends);
console.log(result.getAge());
console.log(result.sex);
console.log(result.constructor)
