Javascript继承

1、继承是和作用域有极大的关系
  函数具有作用域
  {}没有块级作用域（ES6中如果生命了let const就会有块级作用域）
  外部作用域无法访问内部部作用域变量，内部可以访问外部
  内部作用于搜索变量，先从自身搜索，再向上搜索
  如果内部没有声明var 则会产生变量提升

var age=10;
function superType(){
  age=12;            如果是var age=12；则最后是10
  console.log(age);==>12
}
superType();
console.log(age);  ==>12   

2、继承的最主要的目的：
  1）拥有自己的属性
  2）所有实例共享同一个方法
3、Javascript的几种继承方式
  1）原型继承

function superType(){
  this.age='12';
  this.fam=[1,2];
}
function subType(){
}
subType.prototype=new superType();
var s1=new subType();
s1.fam.push(3);
s1.age=13;
var s2=new subType();
s2.fam.push(4);
s2.age=14;
console.log(s1.fam);
console.log(s2.fam);
console.log(s1.age);
console.log(s2.age);

输出结果：

[ 1, 2, 3, 4 ]
[ 1, 2, 3, 4 ]
13
14

那么这种继承的最大弊端就是，引用类型的变量会共享，因为在原型链中自己的作用域并没有含有引用类型的变量，只是存了一个地址的值

console.log(s1.hasOwnProperty('fam'));   ==》false
console.log(s1.hasOwnProperty('age'));   ==》true

所以为了解决这个弊端，需要其他方式
2）构造函数
组合继承就是为了解决引用类型的值共享的问题，唯一的办法就是在自己作用域中有引用类型的值，自然就会想到call了，call不就是改变作用域么？

function superType(){
  this.age='12';
  this.fam=[1,2];
}
function subType(){
    superType.call(this);    //加这么一句代码
}
subType.prototype=new superType();
var s1=new subType();
s1.fam.push(3);
s1.age=13;
var s2=new subType();
s2.fam.push(4);
s2.age=14;
console.log(s1.fam);
console.log(s2.fam);
console.log(s1.age);
console.log(s2.age);

输出：

[ 1, 2, 3 ]
[ 1, 2, 4 ]
13
14

看一下作用域中的情况

console.log(s1.hasOwnProperty('fam'));   ==》true
console.log(s1.hasOwnProperty('age'));   ==》true

好了，现在不存在引用类型的值的问题了，但是方法没法共享啊，如果所有方法都在构造函数中写，那么不是所有的子类都有了同一个方法，这不是浪费内存么，最好能够共享方法
3）组合式继承
我们先看一下非组合式继承的问题

function superType(){
  this.age='12';
  this.fam=[1,2];
  this.sayHello=function (){
    console.log(this.age);
  }
}
function subType(){
    superType.call(this);
}
subType.prototype=new superType();
var s1=new subType();
s1.fam.push(3);
s1.age=13;
var s2=new subType();
s2.fam.push(4);
s2.age=14;
console.log(s1.hasOwnProperty('sayHello'));    ==》true
console.log(s2.hasOwnProperty('sayHello'));    ==》true

可以看到sayHello在所有的实例中都存在，这就造成了浪费
那么我们可以借助原型prototype实现（prototype就是父类能够共享的方法或者属性）

function superType(){
  this.age='12';
  this.fam=[1,2];
  console.log('调用');
}
superType.prototype.sayHello=()=>{
    console.log(this.age);
}
function subType(){
    superType.call(this);
}
subType.prototype=new superType();
var s1=new subType();
s1.fam.push(3);
s1.age=13;
var s2=new subType();
s2.fam.push(4);
s2.age=14;
console.log(s1.hasOwnProperty('sayHello'));    ==》false
console.log(s2.hasOwnProperty('sayHello'));    ==》false

但是组合式继承有什么问题呢？
会调用两次构造方法。。。。。。。。这不是浪费么。。。。。。上述会出现三次调用
那么有没有什么好用的方法可以不两次调用呢？
4）Object.create
Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象。

function superType(){
  this.age='12';
  this.fam=[1,2];
}
superType.prototype.sayHello=()=>{
    console.log(this.age);
}
function subType(){
    superType.call(this);
}
subType.prototype=Object.create(superType.prototype);  //代替subType.prototype=new superType();
var s1=new subType();
s1.fam.push(3);
s1.age=13;
var s2=new subType();
s2.fam.push(4);
s2.age=14;
console.log(s1.fam);
console.log(s2.fam);
console.log(s1.age);
console.log(s2.age);
console.log(s1.hasOwnProperty('sayHello'));
console.log(s2.hasOwnProperty('sayHello'));

如果没有Object.create方法可以采用下面的替代方式

if (!Object.create) {
     Object.create = function(o) {
     function F(){}
     F.prototype = o;     
     return new F();
     };
}