复制代码代码如下所示：
<！——
*
每个对象实例的属性，其成员的实例对象（暂称父对象）的原型（原型）
我们将这种关系称为父原型，如原型链原型}。
原型也有父原型，因为它通常是对象实例，除非我们人为地更改它。
在Javaｓｃｒｉｐｔ中，一切都是对象，函数是第一种类型。
函数和对象都是函数的例子。
功能点功能的原型母原型，和function.prototype母原型对象的原型
对象的父原型还指向函数的原型，而Object.prototype是所有母原型的顶层。
在SpiderMonkey引擎原型，家长可以通过__proto__
* /
function.prototype.hi =函数（）{ alert（嗨功能'）；}
object.prototype.hi =函数（）{ alert（嗨对象'）；}
var =函数（）{（）
this.txt = ；
}
a.prototype = { {
说：函数（）{ alert（' '）；}
}
警报（一个是功能）； / /一个是函数的一个实例；
警报（a.__proto__ =函数原型）；父亲原型 / /指向一个函数原型；
警报（函数实例对象）； / /函数是对象的一个实例；
警报（功能。__proto__ =函数原型）；父亲原型 / /功能点的函数原型；
警报（函数原型。__proto__ =对象。原型）；父亲的原型 / /函数原型指向对象的原型
警报（对象。__proto__ =函数原型）；父亲原型 / /对象指向一个函数原型；
警报（对象的原型。__proto__）； / /对象的原型是所有母原型的顶部，它不再有母原型；

警报（a.prototype实例对象）； / /原型也是一个对象
警报（a.prototype。__proto__ = = =对象。原型）； / /原型原型对象原型的父亲

Var（a =函数）{ }；
a.prototype =新一（）；
a.prototype.say =函数（）{
警报（A）；
}
警报（一个是功能）； / /一个是函数的一个实例
警报（a.__proto__ =函数原型）；父亲原型 / /指向一个函数原型
警报（a.prototype实例一）； / /的原型是一个实例
警报（a.prototype。__proto__ = a.prototype）；对 / /原型样机的父亲指着一个原型

VaR是=新（一）； / / IA是一，是__proto__ = a.prototype实例。
VaR IB =新（一）； / / IB是一个实例，ib.__proto__ = a.prototype
IA.hi（）；
*
IA本身没有HI方法（不在结构中，也不是由它自己定义）。
所以，IA。__proto__是a.prototype，不是发现。
所以a.prototype。__proto__是a.prototype，仍然没有发现，
继续寻找a.prototype。__proto__，Object.prototype，哇，觉得你好，并调用它，停止查找
输出：HI对象
* /
IB.hi（）；
*
IB本身没有HI方法（不在结构中，也不定义它本身）。
所以ib.__proto__是a.prototype，仍然没有发现，
继续寻找a.prototype。__proto__，Object.prototype，哇，觉得你好，并调用它，停止查找
输出：HI对象
* /
A.hi（）；
*
A本身没有HI方法（不在结构中，也不由它自己定义）。
所以找a.__proto__ function.prototype，哇，发现你好，并调用它，停止寻找
输出：HI功能
* /
IA.say（）；
*
IA本身没有说法（不是结构，也不是定义本身）。
所以寻找IA。__proto__，a.prototype，哇，发现说，叫它，停止寻找
所以，这里的电话是A.prototype.say
输出：一个
* /
IB.say（）；
*
IB本身没有说法（不是在结构中，也不是定义本身）。
所以寻找ib.__proto__，a.prototype，哇，发现说，叫它，停止寻找
所以，这里的电话是a.prototype.say
输出：一个
* /
IA.bad（）；
*
IA本身没有坏的方法（不在结构中，也不是由它自己定义）。
所以，IA。__proto__是a.prototype，不是发现。
所以a.prototype。__proto__是a.prototype，仍然没有发现，
继续寻找a.prototype。__proto__，object.prototype，最终没能找到，停止查找
返回错误，ia.bad不是一个函数
* /





感谢西蒙的修正案！在查找属性方法时，所有实例都不会查找自己的原型（实例的原型不在原型链中，只是作为一个属性）！