javascript的继承方式总结

实现继承大致可分为两类
1.基于构造器工作模式
2.基于对象工作模式
----------------------
A 是否使用原型
B 是否执行属性拷贝
C 两者都有（原型属性拷贝）
1.原型链法 Children。prototype = new Parent()
所属模式 1、A

function Shape() {
    this.name="Shape";
    this.toString = function() {
        return this.name;
    };
}
function TwoDShape() {
    this.name = '2D shape';
}
function Triangle(side, height) {
    this.name = 'Triangle';
    this.side = side;
    this.height = height;
    this.getArea = function() {
        return this.side *this.height /2;
    };
}
//用构造器Shape()(通过new操作符)另建了一个新的对象，然后用它覆盖TwoDShape构造器的prototype属性。Triangle也一样。
TwoDShape.prototype = new Shape ();
Triangle.prototype =new TwoDShape ();
//对对象prototype属性进行完全替换时，可能会对对象的constructor属性产生一定副作用。因此，对对象constructor属性进行重置是个很好的习惯
TwoDShape.prototype.constructor = TwoDShape;
Triangle.prototype.constructor = Triangle;

var my  = new Triangle(5,10);
my.getArea(); //25
my.toString  //'Triangle'

2.仅从原型继承法 Child.prototype = Parent.prototype;
所属模式 1 B

function Shape() {
    Shape.prototype.name = 'shape';
    Shape.prototype.toString = function() {
        return this.name;
    }
}
function TwoDShape () {}
TwoDShape.prototype =Shape.prototype;
TwoDShape.prototype.constructor = TwoDShape;//必须在扩展之前完成继承
TwoDShape.prototype.name = '2D shape'; 
function Triangle(side, height) {
    this.side = side;
    this.height =height
}
Triangle.prototype = TwoDShape.prototype;
Triangle.prototype.constructor = Triangle;
Triangle.prototype.name = 'Triangle';
Triangle.prototype.getArea = function (argument) {
    return this.side * this.height /2;
}
var my = new Triangle(5,10);
my.getArea();//25
my.toString(); //'Triangle'
//缺点 子对象  的修改会影响 父对象
var s = new Shape();
s.name; //'Triangle'

3.临时构造器  new F()

所属模式 1 C 

不同于第一种方式，她只会继承于parent的原型属性

function extend (Child, Parent){
    var F = function (){};
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype; // 通过uber可以访问父对象
}

4.原型属性拷贝法
所属模式 1 C

function extend2 (Child,Parent) {
    var p = Parent.prototype;
    var c = Child.prototype;
    for( var i in p ){
        c[i] = p [i]
    }
    c.uber = p;
}

上面4中都是基于构造器的工作模式，下面几种是基于对象的工作模式
5.全属性拷贝法(浅属性拷贝法)
所属模式 2 B

function extendCopy(p){
    var c = {};
    for (var i in p){
        c[i] = p[i];
    }
    c.uber = p;
    return c;
}

6.深拷贝法
所属模式 2 B

function deepCopy(p,c) {
    c =  c || {};
    for(var i in p){
        if(p.hasOwnProperty(i)){
            if (typeof p[i] ==='object'){
                c[i] = Array.isArray(p[i] ? [] : ?);
                deepCopy[p[i],c[i]]
            }else{
                c[i] = p[i]
            }
        }    
    }
    return c;
}

7.原型继承法
所属模式 2 A

function object(o) {
    function F() {}
    F.prototype = o;
    return new F()
}

8.扩展与增强模式
所属模式 2 C 方式 5 7 的混合

function objectPlus(o,stuff){ //对象o用来继承 对象stuff用于拷贝方法与属性 
    var n ;
    function F() {}
    F.prototype = o;
    n.uber =o;
    for (var i in stuff) {
        n[i] = stuff[i];
    }
    return n;
}

9.多重继承法
所属模式 2 B
按照父对象出现的顺序依次对他们执行属性全拷贝

function multi() {
    var n = {},stuff,j = 0,len=arguments.length;
    for(j= 0; j< len; j++) {
        stuff = arguments[j];
        for(var i in stuff){
            n[i] = stuff[i];
        }
    }
    return n ;
}

10.寄生继承法 

所属模式 2 A

function parasite(victim) { //父对象victim
    var that = object(victim); 
    that.more = 1;
    return that;
}
//例子
var Parent = {
    name :'parent',
    num:10
}
function Son(m){
    var that = new Object(Parent);
    that.name='son';
    that.getRun = function () {
        return that.name + 'runs' + this.m +'m' ;
    }
}
var t = Son(200);
t.getRun() //son runs 200m
t.num //10

11.构造器借用法
所属模式 基于构造器

function Parent(id) {
    this.id = id;
}
function Son(){
    Parent.apply(this,arguments);
}
var t = new Son(100);
t.id //100

12.构造器借用与属性拷贝法
所属模式 基于构造器 原型链 属性拷贝

function Child() {
    Parent.appply(this,arguments);
}
extend2(Child, Parent);