//region A
function A(a){
    this.a=a
    console.log(this.a)
}

A.prototype.AShow=function(){
    console.log(this.a+':show')
}
//endregion

//region B
function B(a,b){
    A.call(this,a)
    this.b='b'
    console.log(this.b)
}

// Object.setPrototypeOf( B.prototype, A.prototype )// ES6+，B继承A，修改既存的`B.prototype`

B.prototype=Object.create(A.prototype)// ES5，B继承A，扔掉默认既存的`B.prototype`
Object.defineProperty(B.prototype,'constructor',{// ES5，修复B继承A后丢失的.constructor
    enumerable:false,
    writable:true,
    configurable:true,
    value:B// 使‘.constructor’指向‘B’
})

B.prototype.BShow=function(){
    console.log(this.b+':show')
}

var b = new B('a','b')
b.AShow()
b.BShow()
//endregion

重要的部分是B.prototype=Object.create(A.prototype)。Object.create(..)凭空创建了一个“新”对象，并将这个新对象内部的[[Prototype]]链接到你指定的对象上（在这里是A.prototype）。

换句话说，这一行的意思是：“做一个新的链接到 ‘A.prototype’ 的 ‘B.prototype’ 对象”。

“（原型）继承”

类继承

unction SuperClass(){
    this.superValue = true;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}

function SubClass(){
    this.subValue = true;
}
SubClass.prototype = new SuperClass()//继承父类
SubClass.prototype.getSubValue = function(){return this.subValue;}

//console.log(SubClass.prototype instanceof SuperClass)//=>true

构造函数继承

function SuperClass(value){
    this.superValue = value;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}

function SubClass(value){
    SuperClass.call(this, value);//继承父类
    this.subValue = value;
}
SubClass.prototype.getSubValue = function(){return this.subValue;}

// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.getSubValue());//=>10
// console.log(instance.getSuperValue());//=>'TypeError'

组合继承

function SuperClass(value){
    this.superValue = value;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}

function SubClass(value){
    SuperClass.call(this, value);//构造函数继承父类的 superValue
    this.subValue = value;
}
SubClass.prototype = new SuperClass();//类继承父类原型 getSuperValue
SubClass.prototype.getSubValue = function(){return this.subValue;}

// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.getSubValue());//=>10
// console.log(instance.getSuperValue());//=>10

原型继承

function inheriteObject(o){
    //声明过渡函数对象
    function F(){}
    //过渡函数对象的原型继承父对象
    F.prototype = o;
    //返回过渡对象的一个实例，这个实例继承了父对象
    return new F();
}

// var superObject = {
//     name: 'books',
//     books:['css','javascript']
// }
// var newSubObject = inheriteObject(superObject);
// console.log(newSubObject.name);//=>'books'
// newSubObject.books.push('html');
// console.log(newSubObject.books);//=>['css','javascript','html']

寄生式继承

var superObject = {
    name: 'books',
    books:['css','javascript']
}
function creatBook(obj){
    var o = inheriteObject(obj);
    o.getBooks = function(){
        console.log(name)
    }
    return o;
}

寄生组合式继承


/**
 * 寄生组合式继承
 * @param subClass 子类
 * @param superClass 父类
 */
function inheritePrototype(subClass,superClass){
    //复制父类的原型
    var p = inheriteObject(superClass.prototype);
    //修正因为重写父类原型导致子类 constructor 属性被修改
    p.constructor = subClass;
    //设置子类的原型
    subClass.prototype = p;
}

// //定义父类
// function SuperClass(value){
//     this.superValue = value;//父类属性
// }
// //定义父类原型方法
// SuperClass.prototype.getSuperValue = function(){
//     console.log(this.superValue);
// }
// //定义子类
// function SubClass(value){
//     SuperClass.call(this, value);//构造函数继承
//     this.subValue = value;//子类属性
// }
// inheritePrototype(SubClass, SuperClass);//寄生式继承父类原型
// //子类增加原型方法
// SubClass.prototype.getSubValue = function(){
//     console.log(this.subValue);
// }
// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.subValue);//=>10
// instance.getSuperValue();//=>10
// instance.getSubValue();//=>10