JavaScript原型链 proto的默认指向

不念不忘少年蓝@ 2022-04-24 02:00 181阅读 0赞

JavaScript的原型链系统着实让人头痛，在查阅了各种资料之后，终于总结出了基于几条通用规则和少数例外情况的js原型链逻辑，下面就让我们来一起看看是怎样的一个原理。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hZXJjaGkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

![20190411172347727.png][]

虽然JavaScript里**一切皆对象**，但为了理解原型链系统，我们需要将JavaScript的对象分为`对象`和`函数`两大类。在此基础上，JavaScript的原型链逻辑遵从以下通用规则：

### 通用规则 ###

1.  `对象`有`__proto__`属性，`函数`有`prototype`属性；
2.  `对象`由`函数`生成;
3.  生成`对象`时，`对象`的`__proto__`属性指向`函数`的`prototype`属性。

在没有手动修改`__proto__`属性的指向时，以上三条便是JavaScript默认原型链指向逻辑。

下面我们来从最一般的情况开始，逐步深入的详细解释一下：

1. 一般情况

创建空对象时，实际上我们是用Object函数来生成对象的：
    >var o = {}
    >o.__proto__ === Object.prototype
    true
    
    我们也可以显式的使用Object函数来创建对象：
    >var o = Object()
    o.__proto__ === Object.prototype
    true
    
    当我们使用函数来创建自定义的对象时，上面的规则同样适用：
    >function MyObj(){}
    >typeof MyObj
    "function"
    >var mo = new MyObj()
    >mo.__proto__ === MyObj.prototype
    true

2. 函数对象

既然JavaScript里“一切皆对象”，那`函数`自然也是`对象`的一种。对于`函数`作为`对象`来说，上面的规则同样适用：

函数对象都是由Function函数生成的：
    >function fn(){}
    >fn.__proto__ === Function.prototype
    true

我们可以看到，把函数当做对象时，生成它的函数就是 `Function`函数。那`Function`函数本身呢？同样适用！

Function函数本身作为对象时，生成它的函数是他自身！
    >Function.__proto__ === Function.prototype
    true

同样我们知道，Object函数也是一个函数对象，那么它是否符合上面的规则呢？当然！

Object函数既然是函数，那生成它的函数自然是Function函数咯：
    >Object.__proto__ === Function.prototype
    true

3. prototype是谁？

好了，现在我们知道，对象的`__proto__`属性是从生成它的函数的`prototype`那里得来的，那我们不禁要问，函数的`prototype`又是谁？

一般函数默认的prototype是系统自动生成的一个对象：
    >function fn(){}
    >typeof fn.prototype
    "object"
    >fn.prototype
    {constructor: ƒ}
        constructor: ƒ fn()
        __proto__: Object
    
    >fn.prototype.constructor === fn
    true
    >fn.prototype.__proto__ === Object.prototype
    true

**一般**函数默认的`prototype`是一个类型为`"object"`的对象，它有两个属性：`constructor`和 `__proto__`。其中`constructor`属性指向这个函数自身，`__proto__`属性指向`Object.prototype`，这说明**一般**函数的`prototype`属性是由`Object`函数生成的。

4. 特殊情况

前面我们特别强调了是**一般**函数，那不一般的函数是谁呢？当然是Object函数和Function函数！  
先来看`Object.prototype`:

>typeof Object.prototype
    "object"
    >Object.prototype
    {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
        constructor: ƒ Object()
        hasOwnProperty: ƒ hasOwnProperty()
        isPrototypeOf: ƒ isPrototypeOf()
        propertyIsEnumerable: ƒ propertyIsEnumerable()
        toLocaleString: ƒ toLocaleString()
        toString: ƒ toString()
        valueOf: ƒ valueOf()
        __defineGetter__: ƒ __defineGetter__()
        __defineSetter__: ƒ __defineSetter__()
        __lookupGetter__: ƒ __lookupGetter__()
        __lookupSetter__: ƒ __lookupSetter__()
        get __proto__: ƒ __proto__()
        set __proto__: ƒ __proto__()

可以看到`Object`函数的`prototype`属性也是一个类型为`"object"`的对象，但和一般函数的默认`prototype`属性不一样的是，它多了一大堆方法，这些方法都是JavaScript对象的系统默认方法。  
再仔细看，好像少了什么，对了，Object函数的`prototype`属性里没有`__proto__`属性，我们试着把它的`__proto__`属性打出来看看：

>Object.prototype.__proto__
    null

这就是Object函数特殊情况了：`Object.prototype.__proto__ === null`，我们知道，这就是JavaScript原型链的终点了。  
为什么要这样设定呢？  
`typeof Object.prototype === "object"`，说明它是一个Object对象，如果它由Object函数生成，于是按照我们上面的通用规则，就该是`Object.prototype.__proto__ === Object.prototype`。  
啊哈，问题出现了，`Object.prototype.__proto__`属性指向了它自身，这样以`__proto__`属性构成的原型链就再也没有终点了！所以**为了让原型链有终点**，在原型链的最顶端，JavaScript规定了`Object.prototype.__proto__ === null`。

好，现在再来看Function函数吧：

>typeof Function.prototype
    "function"

一上来就不走寻常路，Function函数的`prototype`属性是一个`"function"`类型的对象，而不像其他函数是类型为`"object"`的对象。那是个什么样的函数呢？

>Function.prototype
    ƒ () { [native code] }

函数内部是`[native code]`，也就是系统编译好的二进制代码函数，这就暂时没法深究了。现在让我们来看看我们最关心的`__proto__`属性：

>Function.prototype.__proto__
    {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
        constructor: ƒ Object()
        hasOwnProperty: ƒ hasOwnProperty()
        isPrototypeOf: ƒ isPrototypeOf()
        propertyIsEnumerable: ƒ propertyIsEnumerable()
        toLocaleString: ƒ toLocaleString()
        toString: ƒ toString()
        valueOf: ƒ valueOf()
        __defineGetter__: ƒ __defineGetter__()
        __defineSetter__: ƒ __defineSetter__()
        __lookupGetter__: ƒ __lookupGetter__()
        __lookupSetter__: ƒ __lookupSetter__()
        get __proto__: ƒ __proto__()
        set __proto__: ƒ __proto__()

怎么有种似曾相识的感觉呢？看起来很像是`Object.prototype`，让我们来试试：

>Function.prototype.__proto__ === Object.prototype
    true

果然就是它！  
按照我们最开始提出的通用规则，一个`"function"`类型的对象，应该是由Function函数生成的，那它的`prototype`属性应该指向`Function.prototype`，也就是`Function.prototype.__proto__ === Function.prototype`。和Object函数同样的问题出现了：循环引用。所以JavaScript规定`Function.prototype.__proto__ === Object.prototype`，这样既避免了出现循环引用，又让`__proto__`构成的原型链指向了唯一的终点：`Object.prototype.__proto__ === null`。

5. 总结

至此，我们从最一般的对象一直追溯到了Object函数和Function函数，并找在原型链的顶端发现了两个例外情况，也知道了这两个例外个规定是为了让`__proto__`构成的原型链存在一个唯一的终点。

**现在我们再来看这张JavaScript原型链的图，是不是一目了然了呢？**

![Image 1][]

JavaScript的原型链系统

作者：two2to  
链接：https://www.jianshu.com/p/686b61c4a43d  
来源：简书  
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hZXJjaGkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20220221/eefc2964dab0430c9dab1ac70e6574a4.png
[20190411172347727.png]: /images/20220221/4de2bd5425894b109bc61397c3d381dd.png
[Image 1]: