SOURCE

// 类的原型对象 prototype 
// 类的原型 __proto__ 

// function A() {
//     this.id = 1
// }
// A.prototype.name = [1]
// A.prototype.type = 'x'
// A.prototype.getId = function() {
//     return this.id
// }
// function B() {

// }

// const a = new A() // a.__proto__ = A.prototype 将实例的__proto__指向类的prototype

// B.prototype = a // B.prototype = a.__proto__

// var b = new B() 

// console.log(b.getId()) // 子类实例可访问到父类原型的方法
// console.log(b.id) // 子类实例可访问到父类实例的属性

// // instanceof通过原型链判断，b 是 B的实例，而 B.prototype = A.prototype，所以 b是A的实例
// console.log( b instanceof B )
// console.log( b instanceof A )
// console.log( B instanceof A ) // 此处是将A的实例赋值给B的原型对象实现继承效果，而不是B类，所以应该是B的原型对象继承了A
// console.log( B.prototype instanceof A ) 


// const b1 = new B()
// const b2 = new B()
// console.log(b2.name)
// console.log(b2.type)
// b1.name.push(2) // 改变父类公共属性(引用类型)的值(内部值)，会影响到其他实例
// b1.type = 'y'
// console.log(b2.name)
// console.log(b2.type)

// 组合式继承：在子类构造函数里执行父类构造函数，将子类原型对象赋值为父类实例。
// function A(id) {
//     this.id =id
//     this.name = 'zhang gong'
// }
// A.prototype.getId = function() {
//     return this.id
// }
// function B(id) {
//     A.call(this,id)
// }
// B.prototype = new A()
// const b = new B(1)
// console.log(b.id)

// 原型式继承：类继承的封装
// function C(o) { // o是父类实例
//     function F() {}
//     F.prototype = o;
//     return new F();
// }
// const c = new C(new A(2)) // C里没有给this添加属性或方法，所以new C()效果与C()一样
// console.log(c.id)

// 寄生式继承：原型式继承的封装
// function createC(obj) { // obj是父类实例
//     var o = new C(obj);
//     o.getId = function() { // 给子实例添加新方法
//         return 2
//     }
//     return o;
// }

// console.log(new C(new A(1)))


// function D(child,parent) {
//     // p既不是父类实例，也不是子类实例，它的构造器是子类
//     var p = C(parent.prototype) // 复制一份父类的原型副本保存在变量，约等于父类实例
//     p.constructor = child // 修改假父类实例(p)的构造器为子类构造器
//     child.prototype = p // 类式继承：子类原型对象 = 假父类实例；
//     // child.prototype = 的副作用：child.constructor = p.constructor
// }

// function A(id) {
//     this.id = id
// }
// A.prototype.getId = function() {
//     return this.id
// }
// function B(id) {
//     A.call(this,id) // 构造函数式继承
//     this.time = 500
// }
// // B.prototype = new A() // 类式继承
// Cy(B,A)
// const b = new B(3)

// console.log(b.id)
// console.log(b.name)

// function C(o) {
//     const f = function() {}
//     f.prototype = o
//     return new f() // 原型式继承
// }
// function Cx(o) {
//     var f = new C(o) // 寄生式继承
//     f.name = 'my'
//     return f
// }
// function Cy(child,parent) { // 寄生组合式继承
//     var p = Cx(parent.prototype) // 复制父类的原型对象
//     p.constructor = child // 修改复制对象的构造函数
//     child.prototype = p // 复制对象赋值给子类的原型对象（类式继承）
// }

// 继承单个对象的属性
var extend = function(target,source) {
    for(var property in source) {
        target[property] = source[property]
    }
    return target
}

var extendMuit = function() {
    let target = arguments[0],
        len =  arguments.length,
        i = 1,
        currentObj;
    for(; i<len; i++) {
        currentObj = arguments[i]
        for(let property in currentObj) {
            target[property] = currentObj[property]
        }
    }
    return target
}

Object.prototype.extendMuit = function() {
    var len = arguments.length,o,i=0;
    for(; i<len; i++) {
        o = arguments[i];
        for(let p in o) {
            this[p] = o[p]
        }
    }
}

var a = {}
a.extendMuit({aa:1},{bb:2})
console.log(a)