摘要：今天閑來無事，看見幾行小字。又說所有對象，繼承終是。強行押韻一波這首詩的意思就是說的我今天沒有什么事情，然后無意中又在網(wǎng)上看到了任何對象都是從對象繼承而來的這句話。一時興起，便去驗證這句話。

今天閑來無事，看見幾行小字。
又說所有對象，繼承終是Obj。
—— 強行押韻一波

這首詩的意思就是說的我今天沒有什么事情，然后無意中又在網(wǎng)上看到了“任何對象都是從Object對象繼承而來的”這句話。一時興起，便去驗證這句話。ps. 我好像從來在原型鏈上面都沒有走到過Object對象，我今天一定要把它點出來！

首先我們從《JavaScript高級程序（第三版）》里面找到這張圖

此圖片告訴了我們2個道理：

1、一個實例的 [[Prototype]] (__proto__屬性),指向它構(gòu)造函數(shù)的原型對象
這句話聽起來有點兒復(fù)雜，把它簡化一下
一個實例的__proto__屬性，指向它的原型對象
2、一個原型對象的constructor屬性又指回了這個對象

下面我們來console一下ES5構(gòu)造函數(shù)和ES6類的__proto__、prototype
1、es5 和 es6 這兩個實例的__proto__ 指向了它們構(gòu)造函數(shù)的原型對象（簡稱指向了它們的原型對象）

function ES5Fun(language){
  this.name = "ES6Class類";
  this.language = language;
}
ES5Fun.prototype.favorit = "足球";
let es5 = new ES5Fun("中文");


class ES6Class {
  constructor(props){
    this.className = "ES6Class類"
  }
  printfName(){
    console.log("現(xiàn)在printName準(zhǔn)備開始打印")
    this.getName();
  }
  getName(){
    console.log("此類的類名是:" +this.className)
  }
}
let es6 = new ES6Class();


console.log(ES5Fun.prototype)
console.log(ES6Class.prototype)

在chrome中的運行結(jié)果為：

console.log(es5.__proto__ === ES5Fun.prototype)            //true
console.log(es6.__proto__ === ES6Class.prototype)          //true

2、es5 和 es6 這兩個實例的constructor 指向了它們的構(gòu)造函數(shù)

//這是Node 里面運行的結(jié)果
console.log(es5.constructor)        //[Function: ES5Fun]
console.log(es6.constructor)        //[Function: ES6Class]
console.log(es5.constructor === ES5Fun)            //true
console.log(es6.constructor === ES6Class)          //true

3、構(gòu)造函數(shù)ES5Fun 和 ES6Class 的原型對象的 constructor 又指回了它們本身

//這是Node 里面的運行結(jié)果
console.log(ES5Fun.prototype.constructor)                //[Function: ES5Fun]        
console.log(ES6Class.prototype.constructor)              //[Function: ES6Class]  
console.log(ES5Fun === ES5Fun.prototype.constructor)                //true
console.log(ES6Class === ES6Class.prototype.constructor)            //true

所以推導(dǎo)出

console.log(es5.constructor === ES5Fun.prototype.constructor)                //true
console.log(es6.constructor === ES6Class.prototype.constructor)              //true
console.log(es5.constructor === es5.__proto__.constructor)                   //true 
console.log(es6.constructor === es6.__proto__.constructor)                   //true   

下面我要開始開車了
準(zhǔn)備好了嗎？嘟嘟，嘟嘟。嘟嘟，嘟嘟。

首先打印出Function對象本身，看看是什么便于后面參考

//Node 下面的執(zhí)行結(jié)果
console.log(Function)        //[Function: Function]

ES6Class的構(gòu)造函數(shù)是 Function對象

//Node 下面的執(zhí)行結(jié)果
console.log(ES6Class.constructor)          //[Function: Function]
console.log(ES6Class.constructor === Function)           //true

ES6Class的__proto__ 當(dāng)然也就指向它構(gòu)造函數(shù)的原型對象

console.log(ES6Class.__proto__)        //[Function]
console.log(ES6Class.__proto__ === Function.prototype)        //true

那么Function的construct屬性呢？ 神奇的事情出現(xiàn)了，F(xiàn)unction的construct屬性竟然就等于 ES6Class的constructor屬性

console.log(Function.constructor);
console.log(Function.constructor === ES6Class.constructor)

原因是Function的constructor 沒有指向它的構(gòu)造函數(shù)而是指向了它本身（或者說Function的構(gòu)造函數(shù)就是它本身）

console.log(Function.constructor === Function)        //true
console.log(Function.constructor.constructor.constructor.constructor.constructor.constructor.constructor.constructor)        //[Function: Function]
console.log(Function.constructor === Function.constructor.constructor.constructor.constructor.constructor.constructor)       //true 

Function的原型對象等于 ES6Class.__proto__

console.log(Function.__proto__)                //[Function]
console.log(Function.__proto__ === ES6Class.__proto__)        //true
// 再次證明 Function.constructor 指向它自己
console.log(Function.constructor.__proto__)    //[Function]
console.log(Function.constructor.constructor.constructor.constructor.__proto__)        //[Function]

一個對象的原型對象的constructor 指向這個對象自己，這一點兒Function也不例外

console.log(Function.__proto__.constructor);                //[Function: Function]
console.log(Function.__proto__.constructor === Function);            //true

最后我們終于找到了原型鏈的盡頭 Function原型對象的原型對象是一個{ }

console.log(Function.__proto__.__proto__)        //{}
//它再往上的原型對象是一個null
console.log(Function.__proto__.__proto__.__proto__)        //null
//這個原型對象的constructor指向了Object
console.log(Function.__proto__.__proto__.constructor)      //[Function: Object]
console.log(Function.__proto__.__proto__.constructor === Object)        //true

1、Function.constructor 指向它本身，不指向它的構(gòu)造函數(shù)（或者說Function的構(gòu)造函數(shù)就是它本身）這個我也不太清楚
2、Function.__proto__.__proto__.constructor === Object

console了這么多東西，我先去廁所吐了，兄弟們點個贊再走