探索JS里的原型链的奥秘原型链是什么？我先举个栗子讲一讲什么是原型 x 是一个普通的对象，x 有一个隐藏属性叫做 pr

原型链是什么？ 我先举个栗子讲一讲什么是原型 x 是一个普通的对象，x 有一个隐藏属性叫做 proto，这个属性会指向 Object.prototype

var x = {}
x._protp_ === Object.prototype

此时我们会说这个 x 的原型是 Object.prototype 再举个例子讲原型链

var a = []
a._proto_ = Array.prototype

a 这个数组的原型就是 Array.prototype , Array.prototype 同样会有一个 _proto_指向 Obeject.prototype , 这样以来 a 就会有两层原型，就形成了一条原型链怎么设置原型？


const x = Object.create(原型)

// or

const x = new 构造函数()

// or

let animal = {
  eats: true
}

let rabbit = {
  jumps: true
};

rabbit.__proto__ = animal

可以解决再没有 class 的情况下实现继承。以数组 a 来举例，它的原型链为 a ===> Array.prototype ===> Object.prototype

a 是 Array 的实例，a 拥有 Array.prototype 里的属性
Array 继承了 Object
Object 又是 a 的间接实例， a 就会拥有 Object.prototype 里的属性

这样以来 a 就可以同时获得两个原型中的属性。

缺点对比 class 不推荐私有属性原型的设置有两个限制：

引用不能形成闭环。如果我们试图给 proto 赋值但会导致引用形成闭环时，JavaScript 会抛出错误。
proto 的值可以是对象，也可以是 null。而其他的类型都会被忽略
当然，这可能很显而易见，但是仍然要强调：只能有一个 [[Prototype]]。一个对象不能从其他两个对象获得继承。

写入不使用原型

原型仅用于读取属性，对于写入/删除操作可以直接在对象上进行

let animal = {
  eats: true,
  walk() {
    /* rabbit 不会使用此方法 */
  }
};

let rabbit = {
  __proto__: animal
};

rabbit.walk = function() {
  alert("Rabbit! Bounce-bounce!");
};

rabbit.walk(); // Rabbit! Bounce-bounce!

访问器（accessor）属性是个例外，因为赋值（assignment）操作是由settle函数处理的。因此，写入此类属性实际上与调用函数相同

let user = {
  name: "John",
  surname: "Smith",

  set fullName(value) {
    [this.name, this.surname] = value.split(" ");
  },

  get fullName() {
    return `${this.name} ${this.surname}`;
  }
};

let admin = {
  __proto__: user,
  isAdmin: true
};

alert(admin.fullName); // John Smith (*)

// setter triggers!
admin.fullName = "Alice Cooper"; // (**)

alert(admin.fullName); // Alice Cooper，admin 的内容被修改了
alert(user.fullName);  // John Smith，user 的内容被保护了

''this''的值在上面的例子中可能会出现一个有趣的问题：在 set fullName(value) 中 this 的值是什么？属性 this.name 和 this.surname 被写在哪里：在 user 还是 admin？答案很简单：this 根本不受原型的影响。无论在哪里找到方法：在一个对象还是在原型中。在一个方法调用中，this 始终是点符号 . 前面的对象。因此settle调用admin.fullName= 使用 admin 作为 this，而不是user。这是一件非常重要的事儿，因为我们可能有一个带有很多方法的大对象，并且还有从其继承的对象。当继承的对象运行继承的方法时，它们将仅修改自己的状态，而不会修改大对象的状态。例如

// animal 有一些方法
let animal = {
  walk() {
    if (!this.isSleeping) {
      alert(`I walk`);
    }
  },
  sleep() {
    this.isSleeping = true;
  }
};

let rabbit = {
  name: "White Rabbit",
  __proto__: animal
};

// 修改 rabbit.isSleeping
rabbit.sleep();

alert(rabbit.isSleeping); // true
alert(animal.isSleeping); // undefined（原型中没有此属性）
/* 
 这里的 animal 代表“方法存储”，rabbit 在使用其中的方法。
 调用 rabbit.sleep() 会在 rabbit 对象上设置 this.isSleeping 
*/

如果我们还有从 animal 继承的其他对象，像 bird 和 snake 等，它们也将可以访问 animal 的方法。但是，每个方法调用中的 this 都是在调用时（点符号前）评估的对应的对象，而不是 animal。因此，当我们将数据写入 this 时，会将其存储到这些对象中。 for...in 循环

for...in 循环也会迭代继承的属性

let animal = {
  eats: true
};

let rabbit = {
  jumps: true,
  __proto__: animal
};

// Object.keys 只返回自己的 key
alert(Object.keys(rabbit)); // jumps

// for..in 会遍历自己以及继承的键
for(let prop in rabbit) alert(prop); // jumps，然后是 eats

如果你想排除继承属性，那么这儿有一个内建方法 obj.hasOwnProperty(key)：如果 obj 具有自己的（非继承的）名为 key 的属性，则返回 true。总结：

在 JavaScript 中，所有的对象都有一个隐藏的 [[Prototype]] 属性，它要么是另一个对象，要么就是 null。
我们可以使用 obj.proto 访问它（历史遗留下来的 getter/setter，这儿还有其他方法，很快我们就会讲到）。
通过 [[Prototype]] 引用的对象被称为“原型”。
如果我们想要读取 obj 的一个属性或者调用一个方法，并且它不存在，那么 JavaScript 就会尝试在原型中查找它。
写/删除操作直接在对象上进行，它们不使用原型（假设它是数据属性，不是 setter）。
如果我们调用 obj.method()，而且 method 是从原型中获取的，this 仍然会引用 obj。因此，方法始终与当前对象一起使用，即使方法是继承的。
for..in 循环在其自身和继承的属性上进行迭代。所有其他的键/值获取方法仅对对象本身起作用。/

我们可以使用 Object.create 来实现比复制 for..in 循环中的属性更强大的对象克隆方式：

let clone = Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
);

此调用可以对 obj 进行真正准确地拷贝，包括所有的属性：可枚举和不可枚举的，数据属性和 setters/getters —— 包括所有内容，并带有正确的 [[Prototype]]。