设计模式——各种继承方式

一、原型继承

B.prototype=new A; 子类的原型等于父类的一个实例
把父类A中私有的属性和公有的属性都继承过来，变为子类B中公有的属性

　　　　function A() {
this.x = 100;
}
A.prototype = {
constructor: A,
getX: function () {
console.log(this.x);
}
};
function B() {
this.y = 200;
}
B.prototype = new A;
B.prototype.constructor = B;

二、call继承

在子类B的函数体中，把父类A当做普通函数执行，并且让父类A中的this变为子类B的一个实例，这样就相当于把父类A中的所有的私有的属性都增加给子类B的实例了
只能把A中私有的继承过来，当做B中私有的，公有属性的无法进行处理

function A() {
this.x = 100;
}
A.prototype = {
constructor: A,
getX: function () {
console.log(this.x);
}
};
function B() {
this.y = 200;
A.call(this);//-->A.call(b)
}
var b = new B;

　　

三、冒充对象继承

在子类B的函数体中，先获取父类A的一个实例，然后遍历这个实例中的所有属性，把所有的属性依次赋值给子类B的实例的私有的属性
把A中公有的和私有的都变为了B中私有的

　function A() {
this.x = 100;
}
A.prototype = {
constructor: A,
getX: function () {
console.log(this.x);
}
};
function B() {
this.y = 200;
var temp = new A;
for (var key in temp) {
if (key !== "constructor") {
this[key] = temp[key];
}
}
//        this.temp = new A;
//        for (var key in this.temp) {
//            if (key !== "constructor") {
//                this[key] = this.temp[key];
//            }
//        }
//        delete this.temp;
}
var b = new B;
console.dir(b);

四、混合模式：原型模式+call模式
A中私有的在B中私有的和公有的都存在了，A中公有的在B中公有的
虽然A中私有的重复了，但是没有太大的影响，如果非要私有的就是私有的，公有的就是公有的，我们只需要自己在编写一个程序把私有的删掉即可

function A() {
this.x = 100;
}
A.prototype = {
constructor: A,
getX: function () {
console.log(this.x);
}
};
function B() {
this.y = 200;
A.call(this);
}
B.prototype = new A;
B.prototype.constructor = B;
//将B公有中继承了A私有的删除掉，以下可以不写，除非你有强迫症
B.prototype.delPrivate = (function () {
var a = new A;
for (var key in this) {
if (a.hasOwnProperty(key)) {
delete this[key];
}
}
return null;
}).call(B.prototype);
var b = new B;
console.dir(b);

　　

五、中间类继承：在IE下不兼容、我们一般用它只处理内置类

function sum() {
arguments.__proto__ = Array.prototype;
arguments.sort(function (a, b) {
return a - b;
});
return arguments;
}
console.log(sum(12, 23, 15, 23, 14, 15, 16, 10));