javascript 6种继承和call()、apply()、bind() 的用法

js 6种继承
 call()、apply()、bind() 的用法；
 call 和 apply 都是为了改变某个函数运行时的 context 即上下文而存在的，换句话说，就是为了改变函数体内部 this 的指向。
 call 和 apply二者的作用完全一样，只是接受参数的方式不太一样。
 三者都可以改变函数的this对象指向。
三者第一个参数都是this要指向的对象，如果如果没有这个参数或参数为undefined或null，则默认指向全局window。
三者都可以传参，但是apply是数组，而call是参数列表，且apply和call是一次性传入参数，而bind可以分为多次传入。
bind 是返回绑定this之后的函数，便于稍后调用；apply 、call 则是立即执行 。
 一、原型链继承
 重点：让新实例的原型等于父类的实例。
　　　　特点：1、实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性。（新实例不会继承父类实例的属性！）
　　　　缺点：1、新实例无法向父类构造函数传参。
　　　　　　　2、继承单一。
　　　　　　　3、所有新实例都会共享父类实例的属性。（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）
二、借用构造函数继承
重点：用.call()和.apply()将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））
　　　　特点：1、只继承了父类构造函数的属性，没有继承父类原型的属性。
　　　　　　　2、解决了原型链继承缺点1、2、3。
　　　　　　　3、可以继承多个构造函数属性（call多个）。
　　　　　　　4、在子实例中可向父实例传参。
　　　　缺点：1、只能继承父类构造函数的属性。
　　　　　　　2、无法实现构造函数的复用。（每次用每次都要重新调用）
　　　　　　　3、每个新实例都有父类构造函数的副本，臃肿。
三、组合继承（组合原型链继承和借用构造函数继承）（常用）
重点：结合了两种模式的优点，传参和复用
　　　　特点：1、可以继承父类原型上的属性，可以传参，可复用。
　　　　　　　2、每个新实例引入的构造函数属性是私有的。
　　　　缺点：调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数。
四、原型式继承
重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。
　　　　特点：类似于复制一个对象，用函数来包装。
　　　　缺点：1、所有实例都会继承原型上的属性。
　　　　　　　2、无法实现复用。（新实例属性都是后面添加的）
五、寄生式继承
重点：就是给原型式继承外面套了个壳子。
　　　　优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。
　　　　缺点：没用到原型，无法复用。　
六、寄生组合式继承（常用）
　　　　寄生：在函数内返回对象然后调用
　　　　组合：1、函数的原型等于另一个实例。2、在函数中用apply或者call引入另一个构造函数，可传参　
重点：修复了组合继承的问题

//eg:
function Person(name) {
    this.name = name;
    this.sum = function() {
        alert(this.name);
    }
}
Person.prototype.age = 10;
//1.原型链继承
function Per() {
    this.name = 'kk';
}

Per.prototype = new Person(); //重点
Per.prototype.age = 22
var pre1 = new Per();
//重点：让新实例的原型等于父类的实例。
　　　//特点：1、实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性。（新实例不会继承父类实例的属性！）
　　　//缺点：1、新实例无法向父类构造函数传参。
　　　　//　　2、继承单一。
　　　　　//　3、所有新实例都会共享父类实例的属性。（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）
// console.log(pre1.name)
// console.log(pre1 instanceof Person)
//2.构造函数继承
//借用构造函数继承
function Con() {
    // 相同点就是 都是改变this指向，第一个参数都是this指向
    // 不同点，call，bind，第二第三第n个参数都是以逗号隔开，apply的第二个参数都必须放在数组里面
    // 当然三者不限于是string，可以是各种类型，包括函数、object
    Person.call(this,'aa');
    Person.bind(this,'jj')();
    Person.apply(this,['kk']);
    this.age=12;
}
var con1 = new Con();
console.log(con1.name);
//重点：用.call()和.apply()将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））
　　　　//特点：1、只继承了父类构造函数的属性，没有继承父类原型的属性。
　　　　//　　　2、解决了原型链继承缺点1、2、3。
　　　　　//　　3、可以继承多个构造函数属性（call多个）。
　　　　　　//　4、在子实例中可向父实例传参。
　　　　//缺点：1、只能继承父类构造函数的属性。
　　　　　//　　2、无法实现构造函数的复用。（每次用每次都要重新调用）
　　　　　　//　3、每个新实例都有父类构造函数的副本，臃肿。
//3.组合继承（组合原型链继承和借用构造函数继承）（常用）
function SubType(name) {
    this.name = name;
    Person.call(this,name) //借用构造继承
}
SubType.prototype = new Person(); //原型链继承
var sub = new SubType('gal');
console.log(sub.name,sub.age)  //sub.age继承原型链，sub.name继承构造函数
//4.原型式继承
function context(obj) {
    function F() {};
    F.prototype = obj;
    return new F();
}
var con = new Person1();
// con.prototype.age = 10
console.log(con.age)
var con1 = context(con)
console.log(con1.age)
//重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。
　　// 　   特点：类似于复制一个对象，用函数来包装。
	// 　　 缺点：1、所有实例都会继承原型上的属性。
	// 　　　     2、无法实现复用。（新实例属性都是后面添加的）
// 5.寄生式继承
function context(obj) {
    function F() {};
    F.prototype = obj;
    return new F();
}
var con = new Person1();
function conObject(obj) {
    var con = context(obj);
    con.name='lmm';
    return con;
}
var con2 = conObject(con);
console.log(typeof conObject);
console.log(typeof con2);
console.log(con2.name,con2.age);
// 　重点：就是给原型式继承外面套了个壳子。
// 　　　　优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。
// 　　　　缺点：没用到原型，无法复用。

// 6.寄生组合继承
// 寄生：在函数内返回对象然后调用
// 　　　　组合：1、函数的原型等于另一个实例。2、在函数中用apply或者call引入另一个构造函数，可传参　
function subtend(obj) {
    function F(){}
    F.prototype = obj;
    return new F()
}
// subtend 就是F实例的另一种表示法
var con = subtend(Person.prototype);
// con 实例的原型继承了父类构造函数的属性
// 上诉更像是原型链继承，只不过只继承了原型属性
// 组合
function Sub() {
    Person.call(this) //继承父类构造函数的属性
}//解决了组合式两次调用构造函数属性的缺点
Sub.prototype = con;  // 继承了con实例
con.constructor = Sub;//一定要修复实例
var sub1 = new Sub()
console.log(sub.age,'寄生式组合继承')
// 重点：修复了组合继承的问题