JS继承

function A(){
}
function B(){
}

1、原型继承

让子类的原型等于父类的一个实例，但是原来原型上的constructor没有了，会一步步向上找到A中的constructor，因此要加上constructor属性，实例中私有的属性和公有属性都可以继承为子类的公有属性，
[弊端]在一个实例中修改父类的方法，其他实例也会受影响

B.prototype = new A();
B.prototype.constructor = B

2、call方法继承

在子类的函数体中，把父类当作普通函数执行，并让父类中的this变为子类，就相当于把父类中所有的私有属性都赋给子类的实例了，把父类上的私有属性都变为子类的私有属性
[弊端]
只能把父类中私有的继承为子类中私有的，但是父类原型上的公有属性及方法无法继承

function A(){
  this.x = 10;
}
A.prototype = {
  constructor: A,
  ...
}
function B(){
  A.call(this);  // this->B  相当于把A中的this变为B
}

3、冒充对象继承

在子类的函数体中，先获取父类的一个实例，遍历实例中的所有私有公有属性依次赋值给子类的私有属性

function A(){
  .....
}
A.prototype = {
  constructor: A,
  ....
};
function B(){
  constructor = B,
  var pro = new A;
  for(var key in pro){
        if(key in this){
            this["my"+key] = pro[key];
        }
        if(key === 'constructor')
          continue;
        this[key] = pro[key];
    }
}

4、寄生式继承

父类的公有的属性继承为子类的公有属性，私有属性继承为子类中私有属性
IE6-8不兼容

function A(){
  this.x = 10;
}
A.prototype = {
  constructor: A,
  ...
}
function B(){
  A.call(this);   // 存了A中私有的
}
B.prototype = Object.create(A.prototype);  
B.constructor = B;

//  兼容的寄生式继承
function objectCerate(o){
  function fn(){}
  fn.prototype = o;
  return new fn;
}

5、混合模式继承

优化：B.prototype = A.prototype

function A(){
  this.x = 10;
}
A.prototype = {
  constructor: A,
  ...
}
function B(){
  A.call(this);   // 存了A中私有的
}
B.prototype = new A;  // A中私有公有都存在了
B.constructor = B;
// 新建一个方法删除第二次继承的父类中的私有属性
B.deletePrivate = (function() {
  var a = new A;
  for(var key in this){
      if(a.hasOwnProperty(key)){
          delete this[key];
      }
  }
  return null;
}).call(B.prototype);

6、中间类继承 IE不兼容，只处理内置类

function sum() {
    arguments.__proto__ = Array.prototype;
    arguments.sort(function (a,b) {
        return a - b;
    });
    console.log(arguments);
}
sum(12,13,24,6,32,17);