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 ]1314

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

console.log(s1.hasOwnProperty('fam'));   ==》falseconsole.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 ]1314

看一下作用域中的情况

console.log(s1.hasOwnProperty('fam'));   ==》trueconsole.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'));    ==》trueconsole.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'));    ==》falseconsole.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();     };}