JS原形链

https://www.jianshu.com/p/a4e1e7b6f4f8

https://www.cnblogs.com/shuiyi/p/5305435.html

JS中的对象分为两种，

1.普通对象obj
2.函数对象function

任何一个对象都有__proto__,但是只有函数对象有prototype

var o1 = {}; 
var o2 =new Object();
var o3 = new f1();

function f1(){}; 
var f2 = function(){};
var f3 = new Function('str','console.log(str)');

console.log(typeof Object); //function 
console.log(typeof Function); //function

console.log(typeof f1); //function 
console.log(typeof f2); //function 
console.log(typeof f3); //function

console.log(typeof o1); //object 
console.log(typeof o2); //object 
console.log(typeof o3); //object

我们可以new一个函数对象直接获取他的所有属性。

这些属性就归自己所有了。同时自己还可以拿到它的隐性属性。　　

var Person = function(){
　　this.name = "name";

　　this.lala = "lala";
}

Person.prototype.lala = "lalala";//隐性属性

Person.prototype.xixi = "xixixi";//隐性属性

var Person1 = new Person();

1.普通对象person1
2.函数对象Person 

于是person1获取了Person的所有属性，归自己所有，同时还可以得到所有的Person的隐性属性,就是prototype的属性。

因为person1的隐形链 指向了Person的隐性属性。如果有多个级别，那么会一级一级向上面找去

个人理解：

Person.prototype.constructor == Person;
person1.__proto__ == Person.prototype;
person1.constructor == Person;

隐形链：__proto__

隐形属性（或方法）:prototype

通过隐形链可以获取隐形属性。

举个例子：

Array.prototype，里面存放着Array的隐形属性。我们可以console.log(Array.prototype)打印出来

var b = [];

b是Array的小弟，b.constructor == Array;

那么b.__proto__ == Array.prototype;

于是b可以直接用Array的隐性属性。

再举个例子：

var  obj = {};

那么我们发现：obj.constuctor == Object;

既然obj是Object的小弟，那么：obj.__proto__ == Object.prototype;

console.log(Object.prototype);

发现好多隐藏方法，比如：toString，valueOf，都可以直接用了嘻嘻。

再回来看：

person1.constructor == Person;                 //Person的小弟是person1

person1.__proto__ == Person.prototype;  //所以小弟拥有Person的隐藏属性

Person.prototype.constructor == Person; //其实Person.prototype也是Person的小弟，一个特殊的小弟,可以理解为，函数对象的prototype属性，才是链接的对象。