我还没搞懂 JS 中 this 指向及继承，直到有人向我这样解释它

阿里云最近在作活动，低至2折，有兴趣能够看看：promotion.aliyun.com/ntms/yunpar…

---

在理解继承以前，须要知道 js 的三个东西：

1. 什么是 JS 原型链
2. this 的值究竟是什么
3. JS 的new 究竟是干什么的

1、什么是 JS 原型链？

咱们知道 JS 有对象，好比

var obj = { name: 'obj' } 
复制代码

咱们经过控制台把obj 打印出来：

咱们会发现 obj已经有几个属性（方法）了。那么问题来了：valueOf/toString/constructor 是怎么来？咱们并无给 obj.valueOf 赋值呀。

上面这个图有点难懂，手画一个示意图：

咱们发现控制台打出来的结果是：

1. obj自己有一个属性 name (这是咱们给它加的)
2. obj还有一个属性叫作 proto(它是一个对象)
3. obj还有一个属性，包括 valueOf, toString, constructor等
4. obj.__proto__其实也有一个叫作__proto__的属性(console.log没有显示)，值为 null

如今回到咱们的问题：obj 为何会拥有 valueOf / toString / constructor 这几个属性？

答案： 这跟 __proto__有关 。

当咱们「读取」 obj.toString 时，JS 引擎会作下面的事情：

1. 看看 obj 对象自己有没有 toString 属性。没有就走到下一步。

2. 看看 obj.__proto__ 对象有没有 toString 属性， 发现 obj.__proto__ 有 toString 属性， 因而找到了，因此 obj.toString实际就是第2步中找到的 obj.__proto__.toString。

3. 若是 obj.__proto__没有，那么浏览器会继续查看 obj.__proto__.__proto__。

4. 若是 obj.__proto__.__proto__ 也没有，那么浏览器会继续查看 obj.__proto__.__proto__.__proto__。

5.直到找到 toString 或者 __proto__ 为 null。

上面的过程，就是「读」属性的「搜索过程」。而这个「搜索过程」，是连着由 proto 组成的链子一直走的。这个链子，就叫作「原型链」。

共享原型链

如今咱们还有另外一个对象

var obj2 = { name: 'obj2' }
复制代码

如图:

那么 obj.toString 和 obj2.toString 实际上是同一东西， 也就是 obj2.__proto__.toString。 说白了，咱们改其中的一个 __proto__.toString ，那么另一个其实也会变!

差别化

若是咱们想让 obj.toString 和 obj2.toString 的行为不一样怎么作呢？ 直接赋值就行了：

obj.toString = function(){ return '新的 toString 方法' }    
复制代码

小结

1. [读]属性时会沿着原型链搜索

2. [新增]属性时不会去看原型链

2、 this 的值究竟是什么

你可能遇到过这样的 JS 面试题：

var obj = {
  foo: function(){
    console.log(this)
  }
}

var bar = obj.foo
obj.foo() // 打印出的 this 是 obj
bar() // 打印出的 this 是 window   
复制代码

请解释最后两行函数的值为何不同。

函数调用

JS（ES5）里面有三种函数调用形式：

func(p1, p2) 
obj.child.method(p1, p2)
func.call(context, p1, p2) // 先不讲 apply
复制代码

通常，初学者都知道前两种形式，并且认为前两种形式「优于」第三种形式。

咱们方方老师大姥说了，你必定要记住，第三种调用形式，才是正常调用形式：

func.call(context, p1, p2)
复制代码

其余两种都是语法糖，能够等价地变为 call 形式：

func(p1, p2)等价于 func.call(undefined, p1, p2);

obj.child.method(p1, p2) 等价于 obj.child.method.call(obj.child, p1, p2);

至此咱们的函数调用只有一种形式：

func.call(context, p1, p2)
复制代码

这样，this 就好解释了 this就是上面 context。

this 是你 call 一个函数时传的 context，因为你历来不用 call 形式的函数调用，因此你一直不知道。

先看 func(p1, p2) 中的 this 如何肯定：

当你写下面代码时

function func(){
  console.log(this)
}

func()

等价于

function func(){
  console.log(this)
}

func.call(undefined) // 能够简写为 func.call()
复制代码

按理说打印出来的 this 应该就是 undefined 了吧，可是浏览器里有一条规则：

若是你传的 context 就 null 或者 undefined，那么 window 对象就是默认的 context（严格模式下默认 context 是 undefined）

所以上面的打印结果是 window。若是你但愿这里的 this 不是 window，很简单：

func.call(obj) // 那么里面的 this 就是 obj 对象了     
复制代码

回到题目：

var obj = {
  foo: function(){
    console.log(this)
  }
}

var bar = obj.foo
obj.foo() // 转换为 obj.foo.call(obj)，this 就是 obj
bar() 
// 转换为 bar.call()
// 因为没有传 context
// 因此 this 就是 undefined
// 最后浏览器给你一个默认的 this —— window 对象    
复制代码

[ ] 语法

function fn (){ console.log(this) }
var arr = [fn, fn2]
arr[0]() // 这里面的 this 又是什么呢？ 
复制代码

咱们能够把 arr[0]( ) 想象为arr.0( )，虽而后者的语法错了，可是形式与转换代码里的 obj.child.method(p1, p2) 对应上了，因而就能够愉快的转换了：

arr[0]() 
假想为    arr.0()
而后转换为 arr.0.call(arr)
那么里面的 this 就是 arr 了
复制代码

小结：

1. this 就是你 call 一个函数时，传入的第一个参数。
2. 若是你的函数调用不是 call 形式， 请将其转换为 call 形式

3、JS 的 new 究竟是干什么的？

咱们声明一个士兵，具备以下属性：

var 士兵 = {
  ID: 1, // 用于区分每一个士兵
  兵种:"美国大兵",
  攻击力:5,
  生命值:42, 
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防护:function(){ /*护脸*/       }
}
复制代码

咱们制造一个士兵， 只须要这样：

兵营.制造(士兵)           
复制代码

若是须要制造 100 个士兵怎么办呢？

循环 100 次吧：

var 士兵们 = []
var 士兵
for(var i=0; i<100; i++){
  士兵 = {
    ID: i, // ID 不能重复
    兵种:"美国大兵",
    攻击力:5,
    生命值:42, 
    行走:function(){ /*走俩步的代码*/}，
    奔跑:function(){ /*狂奔的代码*/  },
    死亡:function(){ /*Go die*/    },
    攻击:function(){ /*糊他熊脸*/   },
    防护:function(){ /*护脸*/       }
  }
  士兵们.push(士兵)
}

兵营.批量制造(士兵们)
复制代码

哎呀，看起来好简单

质疑

上面的代码存在一个问题：浪费了不少内存

1. 行走、奔跑、死亡、攻击、防护这五个动做对于每一个士兵实际上是同样的，只须要各自引用同一个函数就能够了，不必重复建立 100 个行走、100个奔跑……

2. 这些士兵的兵种和攻击力都是同样的，不必建立 100 次。

3. 只有 ID 和生命值须要建立 100 次，由于每一个士兵有本身的 ID 和生命值。

####改进

经过第一节能够知道 ，咱们能够经过原型链来解决重复建立的问题：咱们先建立一个「士兵原型」，而后让「士兵」的 proto 指向「士兵原型」。

var 士兵原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防护:function(){ /*护脸*/       }
}

var 士兵们 = []
var 士兵
for(var i=0; i<100; i++){
  士兵 = {
    ID: i, // ID 不能重复
    生命值:42
  }

  /*实际工做中不要这样写，由于 __proto__ 不是标准属性*/
  士兵.__proto__ = 士兵原型 

  士兵们.push(士兵)
}

兵营.批量制造(士兵们)
复制代码

优雅？

有人指出建立一个士兵的代码分散在两个地方很不优雅，因而咱们用一个函数把这两部分联系起来：

function 士兵(ID){
  var 临时对象 = {};
  临时对象.__proto__ = 士兵.原型;
  临时对象.ID = ID;
  临时对象.生命值 = 42;
  
  return 临时对象;
}  

士兵.原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防护:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js

 而后就能够愉快地引用「士兵」来建立士兵了：

var 士兵们 = []
for(var i=0; i<100; i++){
  士兵们.push(士兵(i))
}

兵营.批量制造(士兵们)
复制代码

JS 之父看到你们都这么搞，以为何须呢，我给大家个糖吃，因而 JS 之父建立了 new 关键字，可让咱们少写几行代码：

只要你在士兵前面使用 new 关键字，那么能够少作四件事情：

1. 不用建立临时对象，由于 new 会帮你作（你使用「this」就能够访问到临时对象）；
2. 不用绑定原型，由于new 会帮你作(new 为了知道原型在哪，因此指定原型的名字 prototype);
3. 不用 return 临时对象，由于 new 会帮你作；
4. 不要给原型想名字了，由于 new 指定名字为 prototype。

这一次用 new 来写

function 士兵(ID){
  this.ID = ID
  this.生命值 = 42
}

士兵.prototype = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防护:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js
而后是建立士兵（加了一个 new 关键字）：

var 士兵们 = []
for(var i=0; i<100; i++){
  士兵们.push(new 士兵(i))
}

兵营.批量制造(士兵们)
复制代码

new 的做用，就是省那么几行代码。（也就是所谓的语法糖）

注意 constructor 属性

new 操做为了记录「临时对象是由哪一个函数建立的」，因此预先给「士兵.prototype」加了一个 constructor 属性：

士兵.prototype = {
  constructor: 士兵
}
复制代码

若是你从新对「士兵.prototype」赋值，那么这个 constructor 属性就没了，因此你应该这么写：

士兵.prototype.兵种 = "美国大兵"
士兵.prototype.攻击力 = 5
士兵.prototype.行走 = function(){ /*走俩步的代码*/}
士兵.prototype.奔跑 = function(){ /*狂奔的代码*/  }
士兵.prototype.死亡 = function(){ /*Go die*/    }
士兵.prototype.攻击 = function(){ /*糊他熊脸*/   }
士兵.prototype.防护 = function(){ /*护脸*/       }
复制代码

或者你也能够本身给 constructor 从新赋值：

士兵.prototype = {
  constructor: 士兵,
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防护:function(){ /*护脸*/       }
}
复制代码

4、继承

继承的本质就是上面的讲的原型链

1)借助构造函数实现继承

function Parent1() {
   this.name = 'parent1';
 }
 
 Parent1.prototype.say = function () {}
 
 function Child1() {
   Parent1.call(this);
   this.type = 'child';
 }

 console.log(new Child1);
复制代码

打印结果：

这个主要是借用call 来改变this的指向，经过 call 调用 Parent ，此时 Parent 中的 this 是指 Child1。有个缺点，从打印结果看出 Child1并无say方法，因此这种只能继承父类的实例属性和方法，不能继承原型属性/方法。

2)借助原型链实现继承

/**
 * 借助原型链实现继承
 */
function Parent2() {
  this.name = 'parent2';
  this.play = [1, 2, 3];
}

function Child2() {
  this.type = 'child2';
}
Child2.prototype = new Parent2();

console.log(new Child2);

var s1 = new Child2();
var s2 = new Child2();
复制代码

打印：

经过一讲的，咱们知道要共享莫些属性，须要 对象.__proto__ = 父亲对象的.prototype,但实际上咱们是不能直接 操做__proto__，这时咱们能够借用 new 来作，因此 Child2.prototype = new Parent2(); <=> Child2.prototype.__proto__ = Parent2.prototype; 这样咱们借助 new 这个语法糖，就能够实现原型链继承。但这里有个老是，如打印结果，咱们给 s1.play新增一个值 ，s2 也跟着改了。因此这个是原型链继承的缺点，缘由是 s1.__pro__ 和 s2.__pro__指向同一个地址即 父类的prototype。

3)组合方式实现继承

/**
 * 组合方式
 */

function Parent3() {
  this.name = 'parent3';
  this.play = [1, 2, 3];
}

Parent3.prototype.say = function () { }

function Child3 () {
  Parent3.call(this);
  this.type = 'child3';
}

Child3.prototype = new Parent3();

var s3 = new Child3();
var s4 = new Child3();
s3.play.push(4);
console.log(new Child3);
console.log(s3.play, s4.play)
复制代码

打印:

将 1 和 2 两种方式组合起来，就能够解决1和2存在问题，这种方式为组合继承。这种方式有点缺点就是我实例一个对象的时， 父类 new 了两次，一次是var s3 = new Child3()对应 Child3.prototype = new Parent3()还要new 一次。

4)组合继承的优化1

function Parent4() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent4.prototype.say = function () { }

function Child4() {
  Parent4.call(this);
  this.type = 'child4';
}

Child4.prototype = Parent4.prototype;

var s5 = new Child4();
var s6 = new Child4();
复制代码

这边主要为 Child4.prototype = Parent4.prototype， 由于咱们经过构造函数就能够拿到全部属性和实例的方法，那么如今我想继承父类的原型对象，因此你直接赋值给我就行，不用在去 new 一次父类。其实这种方法仍是有问题的，若是我在控制台打印如下两句:

从打印能够看出，此时我是没有办法区分一个对象 是直接 由它的子类实例化仍是父类呢？咱们还有一个方法判断来判断对象是不是类的实例，那就是用 constructor,我在控制台打印如下内容：

咦，你会发现它指向的是父类 ，这显然不是咱们想要的结果， 上面讲过咱们 prototype里面有一个 constructor, 而咱们此时子类的 prototype 指向是 父类的 prototye ,而父类prototype里面的contructor固然是父类本身的，这个就是产生该问题的缘由。

5)组合继承的优化2

/**
 * 组合继承的优化2
 */

function Parent5() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent5.prototype.say = function () { }

function Child5() {
  Parent5.call(this);
  this.type = 'child4';
}

Child5.prototype = Object.create(Parent5.prototype);
复制代码

这里主要使用Object.create()，它的做用是将对象继承到__proto__属性上。举个例子：

var test = Object.create({x:123,y:345});
console.log(test);//{}
console.log(test.x);//123
console.log(test.__proto__.x);//3
console.log(test.__proto__.x === test.x);//true
复制代码

那你们可能说这样解决了吗，其实没有解决,由于这时 Child5.prototype 仍是没有本身的 constructor,它要找的话仍是向本身的原型对象上找最后仍是找到 Parent5.prototype, constructor仍是 Parent5 ,因此要给 Child5.prototype 写本身的 constructor:

Child5.prototype = Object.create(Parent5.prototype);
Child5.prototype.constructor = Child5;
复制代码

参考

[什么是 JS 原型链？][1] [this 的值究竟是什么？一次说清楚][2] [JS 的 new 究竟是干什么的？][3]

你的点赞是我持续分享好东西的动力，欢迎点赞！

交流（欢迎加入群，群工做日都会发红包，互动讨论技术）

干货系列文章汇总以下，以为不错点个Star，欢迎 加群 互相学习。

github.com/qq449245884…

我是小智，公众号「大迁世界」做者，对前端技术保持学习爱好者。我会常常分享本身所学所看的干货，在进阶的路上，共勉！

关注公众号，后台回复福利，便可看到福利，你懂的。

每次整理文章，通常都到2点才睡觉，一周4次左右，挺苦的，还望支持，给点鼓励

[1]: zhuanlan.zhihu.com/p/23090041?… [2]: zhuanlan.zhihu.com/p/23804247 [3]: zhuanlan.zhihu.com/p/23987456?… [4]: www.fundebug.com/?utm_source… [5]: /img/bVbraR4