一、介绍

1.在JS开发的过程中我们一定都听过一句话“万物皆对象”。方法（Function）是对象，它的原型(Function.prototype)也是对象。所以它们共有对象的特点。
即：对象的属性 __ proto__，我们通常把它称为“隐式原型”，一个对象的隐式原型指向构造该对象的构造函数的原型，这也保证了实例能够访问在构造函数原型中定义的属性和方法。
2.方法(Function)，它就是一个特殊的对象，除了有上述__ proto__属性，还有特有的原型属性（prototype），这个属性是指向一个对象的指针，而这个对象包含了所有实例共享的属性和方法（我们把这个对象叫做原型对象）。原型对象也有一个属性，叫做constructor，这个属性指回原构造函数。

二、解析

我们应该如何理解这两句话呢？
我们逐个分析，先看第一句：
首先我们看为什么说Function也是对象

    function a(){ //创建一个函数对象

    }
    a.sex = "boy"; //为a函数对象添加sex属性
    console.log(a.sex); //boy
    delete a.sex; //true
    console.log(a.sex); //undefined

delete 操作符用于删除对象的某个属性，我们也确实为a函数对象添加过sex的属性,Function同理可证。

image.png

那么接下来Function.prototype也是对象，经常给原型链加方法的你一点也不会怀疑。

    console.log(a.constructor,'constructor');//查看一下a是否由Function创建
    //是，那么我们依次打印
    console.log(Function.prototype,'prototype'); 
    console.log(a.__proto__,'__proto__')
    console.log(Function.prototype === a.__proto__,'Function.prototype === a.__proto__')

浏览器很清楚的告诉我们第一个观点是对的：

image.png

那我们看看普通对象是不是也是这样的呢？

    var obj = {};
    console.log(obj.__proto__,'b __proto__');
    console.log(obj.prototype,'b prototype');
    console.log(obj.constructor,'b constructor')
    console.log(obj.__proto__===Object.prototype);

浏览器呈现：

image.png

果然我们第一条观点是成立的。那么我们看第二条，说Function既有__ proto__又有prototype，而且Function的prototype（也就是原型对象）拥有一个constructor的属性，这个属性指回构造函数。
我们再来逐句验证一下，先看一下a的prototype是什么。

    console.log(a.prototype,'prototype'); 

结果：

image.png

确实我们看到了有一个constructor的属性，那么继续看一下这个属性是不是指回去。

    console.log(a.prototype.constructor)

结果：

image.png

嗯果然指向了原函数。果然是这样。好的，那么话题终结。

别逗了，怎么可能这样就结束了呢。我们看下边这张图：

image.png

当初估计绝大多数人看到这个东西的时候都是这种表情：

image.png
慌不慌，感觉刚看懂点东西，你说气人不气人，这一堆又是啥？
这张图上有三个部分：构造函数Foo（），Object（）函数，以及上面提到的Function（）。

分解一下这张图：
1.Foo（）构造函数：

f1,f2是构造函数Foo的两个实例化函数对象，我们刚刚说的对象的__ proto__属性指向了这两个对像的构造函数的prototype属性。我们第二个观点又说了函数是比较特殊的所以Foo函数也有prototype属性并且指向了他的原型对象Foo.prototype。然后这个Foo.prototype又有一个constructor属性指回构造函数Foo()。所以就有了这个部分： image.png
2.Object（）函数：
和Foo()雷同

    var b = new Object();
    console.log(Object.prototype,'Object.prototype'); //构造函数Obejct的原型对象
    console.log(b.__proto__,'b.__proto__'); //实例对象的隐士原型
    console.log(b.__proto__ === Object.prototype,'b.__proto__ === Object.prototype'); //二者的指向验证
    console.log(Object.prototype.constructor,'Object.prototype.constructor'); //构造函数Object的原型对象的构造器

image.png
我们的观点对于对象依然成立： image.png

接下来我们去看看Foo()的原型对象的隐士原型，以及Object（）的原型对象的隐士原型：

    function A(){ //创建一个函数对象
    }
    console.log(A.prototype.__proto__,'A.prototype.__proto__'); 
    var b = new Object();
    console.log(Object.prototype,'Object.prototype');//构造函数Obejct的原型对象
    console.log(Object.prototype === A.prototype.__proto__,'Object.prototype===A.prototype.__proto__'); 
    console.log(Object.prototype.__proto__,'Object.prototype.__proto__'); //构造函数Obejct的原型对象的隐士原型

image.png

如此看来这个图已经很清晰了 接下来只要看看最后一个部分即可。请各位看官自行打印，再此不在验证。
不要以为如此便结束了。
这里先抛出一句话，大家结合上边的整体关系图看一下

“所有构造器/函数的__ proto__都指向Function.prototype，它是一个空函数（Empty function）”

Number.__proto__ === Function.prototype  // true
Boolean.__proto__ === Function.prototype // true
String.__proto__ === Function.prototype  // true
Object.__proto__ === Function.prototype  // true
Function.__proto__ === Function.prototype // true
Array.__proto__ === Function.prototype   // true
RegExp.__proto__ === Function.prototype  // true
Error.__proto__ === Function.prototype   // true
Date.__proto__ === Function.prototype    // true
Math.__proto__ === Object.prototype  // true
JSON.__proto__ === Object.prototype  // true

//除此之外“所有构造器/函数”当然包括自定义的。如下
// 函数声明
function Person() {}
// 函数表达式
var Man = function() {}
console.log(Person.__proto__ === Function.prototype) // true
console.log(Man.__proto__ === Function.prototype)    // true

这说明什么呢？
所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身。所有构造器都继承了Function.prototype的属性及方法。如length、call、apply、bind（ES5）。
Function.prototype也是唯一一个typeof XXX.prototype为 “function”的prototype。其它的构造器的prototype都是一个对象。

console.log(typeof Function.prototype) // function
console.log(typeof Object.prototype)   // object
console.log(typeof Number.prototype)   // object
console.log(typeof Boolean.prototype)  // object
console.log(typeof String.prototype)   // object
console.log(typeof Array.prototype)    // object
console.log(typeof RegExp.prototype)   // object
console.log(typeof Error.prototype)    // object
console.log(typeof Date.prototype)     // object

知道了所有构造器（含内置及自定义）的__ proto__都是Function.prototype，那Function.prototype的__ proto__是谁呢？
相信都听说过JavaScript中函数也是一等公民，那从哪能体现呢？

console.log(Function.prototype.__proto__ === Object.prototype) // true

这说明所有的构造器也都是一个普通JS对象，可以给构造器添加/删除属性等。同时它也继承了Object.prototype上的所有方法：toString、valueOf、hasOwnProperty等。
最后Object.prototype的__ proto__是谁？

Object.prototype.__proto__ === null  // true

如此，这张图就全然明白了，突然想到《道德经》中的一句“道生一，一生二，二生三，三生万物”。老祖宗的智慧真是可怕。
需要注意的是，我们在使用prototype操作的时候，一定是给原型链上添加属性而不是直接对prototype进行复制：

function Person(name) {
    this.name = name
}
// 重写原型
Person.prototype = {
    getName: function() {}
}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true
console.log(p.__proto__ === p.constructor.prototype) // false
console.log(Person.prototype.constructor) // ƒ Object() { [native code] }

使用对象直接量方式定义的对象其构造器（constructor）指向的是根构造器Object，Object.prototype是一个空对象{}，{}自然与{getName: function(){}}不等.
篇幅较长，需要慢慢消化，但是理解之后东西并不多。