原型分为隐式原型（__proto__）和显示原型（prototype）
函数有显示原型和隐式原型，函数的隐式原型一般用于子函数，子函数的隐式原型，指向其父函数。函数的原型一般是指他的显示原型prototype
每个实例对象都有隐式原型__proto__，这个指向构造函数的显示原型
原型是一个对象，我们也称prototype为原型对象
原型的作用是共享方法
function Person() {
}
// 先使用构造函数创建一个对象：
var person = new Person();
person.name = 'Kevin';
console.log(person.name) // Kevin
// Person 就是一个构造函数，我们使用 new 创建了一个实例对象 person。
prototype（显示原型）
每个函数都有一个 prototype 属性，例Person.prototype，函数的 prototype 属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型，显示原型。
Person.prototype.name = 'Kevin';等价于person.name = 'Kevin';
原型：每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型"继承"属性。
// 1. 构造函数的问题.
function Star(uname, age) {//构造函数
this.uname = uname;
this.age = age;
// this.sing = function() {
// console.log('我会唱歌');
// }如果公共方法放在构造函数当中，创建实例的时候，都会为这个方法单独开辟内存空间来存放同一个函数，浪费内存
}
Star.prototype.sing = function() {//原型对象
console.log('我会唱歌');
}
var ldh = new Star('刘德华', 18);//对象实例
var zxy = new Star('张学友', 19);
console.log(ldh.sing === zxy.sing);
// console.dir(Star);
ldh.sing();
zxy.sing();
// 2. 一般情况下,我们的公共属性定义到构造函数里面, 公共的方法我们放到原型对象身上
__proto__（隐式原型）
每一个JavaScript对象(除了 null )都具有的一个属性，叫__proto__，这个属性会指向该对象的原型。这是隐式原型。例person.__proto__
function Person() {
}//构造函数Person
var person = new Person();//由构造函数Person创建出的对象person
//对象.__proto__ === 构造函数.prototype
console.log(person.__proto__ === Person.prototype); // true对象的原型和构造函数的原型是等价的
console.log(Person.prototype.constructor === Person) // true
在构造函数中加属性，原型中加方法
constructor
构造函数属性
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
Star.prototype.sing = function(){
console.log('我会唱歌');
}
var ldh = new Star('刘德华', 18);
var zxy = new Star('张学友', 19);
console.log(ldh.__proto__.constructor == Star.prototype.constructor)//true
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
// 很多情况下,我们需要手动的利用constructor 这个属性指回 原来的构造函数
// Star.prototype.sing = function() {
// console.log('我会唱歌');
// };
// Star.prototype.movie = function() {
// console.log('我会演电影');
// }
Star.prototype = {
// 如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
constructor: Star,
sing: function() {
console.log('我会唱歌');
},
movie: function() {
console.log('我会演电影');
}
}
var ldh = new Star('刘德华', 18);
var zxy = new Star('张学友', 19);
console.log(Star.prototype);
console.log(ldh.__proto__);
console.log(Star.prototype.constructor);
console.log(ldh.__proto__.constructor);
实例与原型
当读取实例的属性时，如果找不到，就会查找与对象关联的原型中的属性，如果还查不到，就去找原型的原型，一直找到最顶层为止。
function Person() {
}
Person.prototype.name = 'Kevin';
var person = new Person();
person.name = 'Daisy';
console.log(person.name) // Daisy
delete person.name;
console.log(person.name) // Kevin
给实例对象 person 添加了 name 属性，当我们打印 person.name 的时候，结果自然为 Daisy。当我们删除了 person 的 name 属性时，读取 person.name，从 person 对象中找不到 name 属性就会从 person 的原型也就是 person.__proto__ ，也就是 Person.prototype中查找，找到了 name 属性，结果为 Kevin。
原型链
JavaScript中所有的对象都是由它的原型对象继承而来。而原型对象自身也是一个对象，它也有自己的原型对象，这样层层上溯，就形成了一个类似链表的结构，这就是原型链。
所有原型链的终点都是Object函数的prototype属性，因为在JavaScript中的对象都默认由Object()构造。Objec.prototype指向的原型对象同样拥有原型，不过它的原型是null，而null则没有原型。
所以查找属性的时候查到 Object.prototype 就可以停止查找了。
var obj = new Object();
obj.name = 'Kevin'
console.log(obj.name) // Kevin
console.log(Object.prototype.__proto__ === null) // true
JS属性查找机制：依次往上找，先查对象本身有没有此属性>原型对象>Object原型对象>Object
class Think{//构造函数
constructor(a){
this.a = a
}
lay(a){
console.log(a)
}
}
let newThink = new Think()//实例对象
console.log(Think.prototype)//构造函数的原型
console.log(newThink.__proto__)//实例对象的原型
console.log(newThink.__proto__===Think.prototype);//都指向Think的原型对象
console.log(newThink.__proto__.constructor === Think)//Think原型对象.constructor指向Think构造函数本身
console.log(Think.prototype.__proto__)//再下一个原型是Object原型对象
console.log(newThink.__proto__.__proto__)
console.log(newThink.__proto__.__proto__===Think.prototype.__proto__);
console.log(newThink.__proto__.__proto__.constructor===Object);//Object原型对象.constructor指向Object构造函数本身
console.log(Think.prototype.__proto__.__proto__)//再下一个原型是null
console.log(newThink.__proto__.__proto__.__proto__)
console.log(newThink.__proto__.__proto__.__proto__===Think.prototype.__proto__.__proto__);
怎么记住呢？记着对象是带把的，所以实例对象对应着带把的__proto__，这个指向构造函数的原型构造函数.prototype
而且prototype在原型链中只出现了一次，那就是最初的函数的原型，其余全部都是对象，Object也是函数
实例对象.__proto__ === 构造函数.prototype两个proto相等
实例对象.__proto__.constructor === 构造函数
实例对象.__proto__.__proto__ === 构造函数.prototype.__proto__
各自再加一层__proto__也相等，对应下一层原型Object原型对象，所以prototype只出现一次
实例对象.__proto__.__proto__.constructor === Object
再加一层原型也相等，这里都是等于null
实例对象.__proto__.__proto__.__proto__ === 构造函数.prototype.__proto__.__proto__
重写原型对象
function Person (){
}
var friends = new Person()
Person.prototype = {
name: "edfewf",
age: "32",
sayName: function(){
console.log(this.name)
}
}
friends.sayName() //error
Person.prototype === friends.__proto__ //false
先创建Person的一个实例，有重写了他的原型对象，friends.sayName()时出错，因为friends指向的原型不包含sayName()函数
ES6原型
每个class都有显示原型prototype，而且也有隐式原型__proto__（class实际就是函数）
每个实例对象都有隐式原型__proto__
实例对象的__proto__指向对应class的protype
子类的隐式原型__proto__指向父类
//类的 prototype 属性和__proto__属性
class A {
}
class B extends A {
}
B.__proto__ === A // true 子类的__proto__属性，表示构造函数的继承，总是指向父类。
B.prototype.__proto__ === A.prototype // true 子类prototype属性的__proto__属性，表示方法的继承，总是指向父类的prototype属性。
//实例的 __proto__ 属性
//子类实例的__proto__属性的__proto__属性，指向父类实例的__proto__属性。也就是说，子类的原型的原型，是父类的原型。
var p1 = new A();
var p2 = new B();
p1.__proto__ === A.prototype // true 实例对象p1的隐式原型等于函数A的显示原型
p2.__proto__ === p1.__proto__ // false
p2.__proto__.__proto__ === p1.__proto__ // true
参考：https://github.com/mqyqingfeng/Blog/issues/2
https://juejin.im/post/5a94c0de5188257a8929d837
https://www.bilibili.com/video/av60299046/?p=26
