我对js中原型原型链的理解（有图有真相）

原型和原型链是 js 中的难点也是重点，明白了 js 中原型和原型链会让我们在后面不管是学习还是工作都会更加高效，并且 js 中原型和原型链也是面试中必不可少的话题。此文是我阅读 javascript 高级程序设计后，对原型和原型链的理解，也当作学习 js 的笔记。希望大家看完此篇文章能让你对 js 原型和原型链有深刻全面的了解。

JS 中的原型和原型链

讲原型的时候，我们应该先要记住以下几个要点，这几个要点是理解原型的关键：

1. 所有的引用类型（数组、函数、对象）可以自由扩展属性（除null以外）。
2. 所有的引用类型都有一个__proto__属性(也叫隐式原型，它是一个普通的对象)。
3. 所有的函数都有一个prototype属性(这也叫显式原型，它也是一个普通的对象)。
4. 所有引用类型，它的__proto__属性指向它的构造函数的prototype属性。
5. 当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它的__proto__属性(也就是它的构造函数的prototype属性)中去寻找。

那么要点说完了，我们就根据这些要点来理解 js 原型和原型链。

js 原型

我们先来看一个原型的例子。

//这是一个构造函数
function Foo(name, age) {
  this.name = name;
  this.age = age;
}
/*根据要点 3，所有的函数都有一个 prototype 属性，这个属性是一个对象
再根据要点 1，所有的对象可以自由扩展属性
于是就有了以下写法*/
Foo.prototype = {
  // prototype 对象里面又有其他的属性
  showName: function() {
    console.log("I'm " + this.name); //this 是什么要看执行的时候谁调用了这个函数
  },
  showAge: function() {
    console.log("And I'm " + this.age); //this 是什么要看执行的时候谁调用了这个函数
  }
}
var fn = new Foo('小明', 19)
/*当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它
构造函数的'prototype'属性中去找*/
Foo.prototype.sex = "男";
fn.showName(); //I'm 小明
fn.showAge(); //And I'm 19

这就是原型，很好理解。那为什么要使用原型呢？

试想如果我们要通过Foo()来创建很多很多个对象，如果我们是这样子写的话：

function Foo(name, age) {
  this.name = name;
  this.age = age;
  this.showName = function() {
    console.log("I'm " + this.name);
  }
  this.showAge = function() {
    console.log("And I'm " + this.age);
  }
}

那么我们创建出来的每一个对象，里面都有showName和showAge方法，这样就会占用很多的资源。

而通过原型来实现的话，只需要在构造函数里面给属性赋值，而把方法写在Foo.prototype属性(这个属性是唯一的)里面。这样每个对象都可以使用prototype属性里面的showName、showAge方法，并且节省了不少的资源。

js 原型链

理解了 js 原型，那么 js 原型链就更好理解了。

原型链是什么呢，根据字面意思我们可以这样理解，就是将原型连成一条链。我们上面讲过，js 每一次获取对象中的属性都是一次查询过程，如果在自有属性中找不到就会去原型对象中查找，如果原型对象中还查不到，就回去原型对象的原型中查找，也就是按照原型链查找，直到查找到原型链的顶端，也就是 Object 的原型。

下面这段话可以帮助理解原型链

根据要点 5，当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它构造函数的prototype属性中去寻找。那又因为prototype属性是一个对象，所以它也有一个__proto__属性。

那么我们来看一个例子：

// 构造函数
function Foo(name, age) {
  this.name = name;
  this.age = age;
}
Object.prototype.toString = function() {
  //this 是什么要看执行的时候谁调用了这个函数。
  console.log("I'm " + this.name + " And I'm " + this.age);
}
var fn = new Foo('小明', 19);
fn.toString(); //I'm 小明 And I'm 19
console.log(fn.toString === Foo.prototype.__proto__.toString); //true
console.log(fn.__proto__ === Foo.prototype) //true
console.log(Foo.prototype.__proto__ === Object.prototype) //true
console.log(Object.prototype.__proto__ === null) //true

是不是觉得有点奇怪？我们通过图来分析一下。

首先，fn的构造函数是Foo()。所以：

fn.__proto__===Foo.prototype

又因为Foo.prototype是一个普通的对象，它的构造函数是Object，所以：

Foo.prototype.__proto__===Object.prototype

通过上面的代码，我们知道这个toString()方法是在Object.prototype里面的，当调用这个对象的本身并不存在的方法时，它会一层一层地往上去找，一直到 null 为止。

所以当fn调用toString()时，JS 发现fn中没有这个方法，于是它就去Foo.prototype中去找，发现还是没有这个方法，然后就去Object.prototype中去找，找到了，就调用Object.prototype中的toString()方法。

这就是原型链，fn能够调用Object.prototype中的方法正是因为存在原型链的机制。

另外，在使用原型的时候，一般推荐将需要扩展的方法写在构造函数constructor的prototype属性中，避免写在 __proto__ 属性里面。

以上关于我对js中原型原型链的理解（有图有真相）的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。