原型和原型链

function Person(){} // 构造函数 Person

let person = new Person() // 实例化

Person 就是构造函数，Person.prototype 就是原型 

 

 prototype 显示原型

原型指的就是一个对象，实例“继承”那个对象的属性。在原型上定义的属性，通过“继承”，实例也拥有了这个属性。“继承”这个行为是在 new 操作符内部实现的。

 _proto_ 隐式原型

实例通过 __proto__ 访问到原型，所以如果是实例，那么就可以通过这个属性直接访问到原型：

实例.__proto__. ==原型

构造函数.prototype==原型 

实例.__proto__. ==  构造函数.prototype

原型.constructor==构造函数

五条原型规则：
1.所有引用类型（数组、对象、函数），都具有对象特性，即可自由扩展属性（null除外）

let obj = {}; obj.a =100;
let arr = []; arr.a = 100;
function fn(){}
fn.a = 100;

2.所有引用类型（数组、对象、函数），都有一个_proto_（隐式原型）属性，属性值是一个普通的对象

console.log(obj.__proto__)
console.log(arr.__proto__)
console.log(fn.__proto__)

3.所有的函数，都有一个prototype（显式原型）属性，属性值是一个普通的对象

console.log(fn.prototype)

4.所有引用类型（数组、对象、函数），_proyo_属性值指向它的构造函数的“prototype”属性值
【obj. _proto_ === Object.prototype（Object就是obj的构造函数，构造函数也是函数所以它也有prototype属性）】

console.log(obj.__proto__ === Object.prototype)

5.当试图得到一个对象的某个属性时，如果这个对象本身没有这个属性，那么会去它的_proto_（即它的构造函数的prototype）中寻找  

例子： 

function Foo(name,age){
    this.name = name
}
Foo.prototype.alertNmae = function (){
    alert(this.name)
}

let f = new Foo('张三')  // 实例中f的 __proto__(隐式原型) 会指向 它的构造函数的prototype(显示原型) 就是Foo的prototype
f.printName = function(){
    console.log(this.name)
}
f.printName() //张三            
f.alertNmae() //张三

console.log(f.__proto__ === Foo.prototype);  // true

 原型链：

1、在f中找某个属性，f中没有，就去f的__proto__（即f的构造函数Foo的prototype）中找；
2、Foo.prototype中也没有，就去Foo.prototype的__proto__（即Foo.prototype的构造函数Object的prototype）中找；
3、Object.prototype中也没有的话，按理说应该继续到Object.prototype的__proto__中寻找，但是JS为了避免死循环将Object.prototype的__proto__设为null，所以到这里还没有找到的话就返回null。【Object.prototype的__proto__为nul是一个特例】