JS继承与原型链

其实MDN上写的非常清晰了，我这里只是为了自己做笔记。https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Inheritance_and_the_prototype_chain

继承时，JavaScript 只有一种结构：对象。每个实例对象（ object ）都有一个私有属性（称之为 proto ）指向它的构造函数的原型对象（prototype ）。该原型对象也有一个自己的原型对象( proto ) ，层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。

几乎所有 JavaScript 中的对象都是位于原型链顶端的 Object 的实例。

基于原型链的继承

继承属性

JavaScript 对象是动态的属性“包”（指其自己的属性）。JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。

遵循ECMAScript标准，someObject.[[Prototype]] 符号是用于指向 someObject 的原型。从 ECMAScript 6 开始，[[Prototype]] 可以通过 Object.getPrototypeOf() 和 Object.setPrototypeOf() 访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 __proto__。

但它不应该与构造函数 func 的 prototype 属性相混淆。被构造函数创建的实例对象的 [[prototype]] 指向 func 的 prototype 属性。**Object.prototype **属性表示 Object 的原型对象。

// 让我们从一个自身拥有属性a和b的函数里创建一个对象o：
let f = function () {
   this.a = 1;
   this.b = 2;
}
/* 这么写也一样
function f() {
  this.a = 1;
  this.b = 2;
}
*/
let o = new f(); // {a: 1, b: 2}

// 在f函数的原型上定义属性
f.prototype.b = 3;
f.prototype.c = 4;

// 不要在 f 函数的原型上直接定义 f.prototype = {b:3,c:4};这样会直接打破原型链
// o.[[Prototype]] 有属性 b 和 c
//  (其实就是 o.__proto__ 或者 o.constructor.prototype)
// o.[[Prototype]].[[Prototype]] 是 Object.prototype.
// 最后o.[[Prototype]].[[Prototype]].[[Prototype]]是null
// 这就是原型链的末尾，即 null，
// 根据定义，null 就是没有 [[Prototype]]。

// 综上，整个原型链如下: 

// {a:1, b:2} ---> {b:3, c:4} ---> Object.prototype---> null

console.log(o.a); // 1
// a是o的自身属性吗？是的，该属性的值为 1

console.log(o.b); // 2
// b是o的自身属性吗？是的，该属性的值为 2
// 原型上也有一个'b'属性，但是它不会被访问到。
// 这种情况被称为"属性遮蔽 (property shadowing)"

console.log(o.c); // 4
// c是o的自身属性吗？不是，那看看它的原型上有没有
// c是o.[[Prototype]]的属性吗？是的，该属性的值为 4

console.log(o.d); // undefined
// d 是 o 的自身属性吗？不是，那看看它的原型上有没有
// d 是 o.[[Prototype]] 的属性吗？不是，那看看它的原型上有没有
// o.[[Prototype]].[[Prototype]] 为 null，停止搜索
// 找不到 d 属性，返回 undefined

给对象设置属性会创建自有属性。获取和设置属性的唯一限制是内置 getter 或 setter 的属性。

继承方法

在 JavaScript 里，任何函数都可以添加到对象上作为对象的属性。
当继承的函数被调用时，this 指向的是当前继承的对象，而不是继承的函数所在的原型对象。

var o = {
  a: 2,
  m: function(){
    return this.a + 1;
  }
};

console.log(o.m()); // 3
// 当调用 o.m 时，'this' 指向了 o.

var p = Object.create(o);
// p是一个继承自 o 的对象

p.a = 4; // 创建 p 的自身属性 'a'
console.log(p.m()); // 5
// 调用 p.m 时，'this' 指向了 p
// 又因为 p 继承了 o 的 m 函数
// 所以，此时的 'this.a' 即 p.a，就是 p 的自身属性 'a' 

在 JavaScript 中使用原型

在 JavaScript 中，函数（function）是允许拥有属性的。所有的函数会有一个特别的属性 —— prototype 。
运行如下代码

function doSomething(){}
console.log( doSomething.prototype );
// 和声明函数的方式无关，
// JavaScript 中的函数永远有一个默认原型属性。
var doSomething = function(){}; // doSomething从Object.prototype继承对象的方法。
console.log( doSomething.prototype );

展开

我们可以给doSomething函数的原型对象添加新属性，如下：

function doSomething(){}
doSomething.prototype.foo = "bar";
console.log( doSomething.prototype );

通过new操作符来创建基于这个原型对象的doSomething实例。

function doSomething(){}
doSomething.prototype.foo = "bar"; // add a property onto the prototype
var doSomeInstancing = new doSomething();
doSomeInstancing.prop = "some value"; // add a property onto the object
console.log( doSomeInstancing );

接下来这段看似话很多，但是非常清晰，不绕。看完就能很透彻的懂原型链 层层向上。

如上所示, doSomeInstancing 中的_ _ proto _ _是 doSomething.prototype. 但这是做什么的呢？当你访问doSomeInstancing 中的一个属性，浏览器首先会查看doSomeInstancing 中是否存在这个属性。

如果 doSomeInstancing 不包含属性信息, 那么浏览器会在 doSomeInstancing 的 _ _ proto _ _ 中进行查找(同 doSomething.prototype). 如属性在 doSomeInstancing 的 _ _ proto _ _ 中查找到，则使用 doSomeInstancing 中 _ _ proto _ _ 的属性。

否则，如果 doSomeInstancing 中 _ _ proto _ _ 不具有该属性，则检查doSomeInstancing 的 _ _ proto _ _ 的 _ _proto _ _ 是否具有该属性。默认情况下，任何函数的原型属性 _ _ proto _ _ 都是 window.Object.prototype. 因此, 通过doSomeInstancing 的 _ _ proto _ _ 的 _ _ proto _ _ ( 同 doSomething.prototype 的 _ _ proto _ _ (同 Object.prototype)) 来查找要搜索的属性。

如果属性不存在 doSomeInstancing 的 _ _ proto _ _ 的 _ _ proto _ _ 中， 那么就会在doSomeInstancing 的 _ _ proto _ _ 的 _ _ proto _ _ 的 _ _ proto _ _ 中查找。然而, 这里存在个问题：doSomeInstancing 的 _ _ proto _ _ 的 _ _ proto _ _ 的 _ _ proto _ _ 其实不存在。因此，只有这样，在 _ _ proto _ _ 的整个原型链被查看之后，这里没有更多的 _ _ proto _ _ ， 浏览器断言该属性不存在，并给出属性值为 undefined 的结论。

在控制台窗口中输入更多的代码，如下：

function doSomething(){}
doSomething.prototype.foo = "bar";
var doSomeInstancing = new doSomething();
doSomeInstancing.prop = "some value";
console.log("doSomeInstancing.prop:      " + doSomeInstancing.prop);
console.log("doSomeInstancing.foo:       " + doSomeInstancing.foo);
console.log("doSomething.prop:           " + doSomething.prop);
console.log("doSomething.foo:            " + doSomething.foo);
console.log("doSomething.prototype.prop: " + doSomething.prototype.prop);
console.log("doSomething.prototype.foo:  " + doSomething.prototype.foo);

结果如下：

其实我在这里一直一直想不通，我总觉得 doSomething.foo的结果应该是bar。直到读了犀牛书的第六章--对象，

通过new创建对象
new运算符创建并初始化一个新对象。关键字new后跟随一个函数调用。这里的函数称做构造函数(constructor)，构造函数用以初始化一个新创建的对象。

再翻上去看引用中的那段话，才能明白。function doSomething(){}是定义一个空构造函数。doSomething.prototype指向其原型对象。doSomeInstancing()是doSomething()的实例，是doSomething原型的继承对象，也因此，doSomething.anything的答案都是undefined。doSomething.prototype才访问到了它的原型对象。

掘金中有一篇文章讲得非常非常好！链接 --> JS原型链与继承别再被问倒了

我的个人感觉是：如果你看的不是很理解的话，八成是代码写少了，多从例子中体会。