原型链

原型链

prototype和______proto__

prototype:显式原型

proto:隐式原型

（个人理解：____proto____指向上一层，prototype指向自身）

通常情况下，构造函数的prototype和构造函数的实例的____proto__都是指向同一个地方的，都是指向原型对象

function Person(name,age){
  this.name = name
  this.age = age
}
Person.prototype.method = 'China'
let person = new Person('test',15)
person.method = 'age'
console.log(Person.prototype)
console.log(person.__proto__)
// { method: 'China' }
// { method: 'China' }
console.log(Person.prototype === person.__proto__)
//true

其中Object,function等都是js内置的构造函数，他们的__proto____

都指向一个顶层的空对象?函数

其中Object是一个构造函数，Object.prototype是这个构造函数的原型对象

其中Function也是一个构造函数

Function.prototype.sayFun = function(){
  console.log('i am function')
}
const a = function(){

}
a.__proto__.sayFun()
// i am function

万物皆对象，函数也是Function构造函数的的实例

function Person(name,age){
  this.name = name
  this.age = age
}
const person = new Person('zd',18)
console.log(Person.__proto__ === Function.prototype)
//true
console.log(Person.__proto__ === Function.__proto__)
//true
console.log(person.__proto__ === Person.prototype)
//true
console.log(person.__proto__ === Function.prototype)
//false
console.log(person.__proto__ === Object.prototype)
//false
console.log(typeof person)
//object

• 函数是Function构造函数的实例
• 对象是Object构造函数的实例(字面量定义的对象或者使用new Object()创建的对象

var F = function(){}
Function.prototype.a = 1
console.log(F.prototype.__proto__ === Object.prototype)
//构造函数的prototype是一个对象，对象的__proto__指向Object构造函数的prototype
//true
console.log(Array.__proto__ === Function.prototype)
//true
console.log(Object.__proto__.__proto__ === Object.prototype)
//true
console.log(Object.prototype === Function.prototype.__proto__)
let obj = {}
let objTest = Object.create({})
console.log(obj.__proto__ === Object.prototype)
console.log(objTest.__proto__.__proto__ === Object.prototype)
console.log(F.prototype.constructor === F)
//构造函数上原型的constructor指向这个构造函数本身
console.log(Function.prototype === Function.__proto__)
//Function构造函数的原型对象与它的__proto__指向是一样的

原型链

__proto__的路径就叫原型链

三条原型链结尾都是Object.prototype，那是不是说明了Object.prototype就是原型链的终点呢？其实不是的，Object.prototype其实也有__proto__，指向null，那才是原型链的终点

test

var F = function() {};

Object.prototype.a = function() {
  console.log('a');
};

Function.prototype.b = function() {
  console.log('b');
}

var f = new F();
console.log(f.__proto__.__proto__ === Object.prototype)
//实例的__proto__指向构造函数的原型，构造函数的原型是个对象，__proto指向Object的prototype
f.a()
// f.b()
//这个是没有的，顺着原型链去找的话，会先找到构造函数的原型，构造函数的原型是个对象，对象的原型是Object.prototype,没有指向过Function的原型，所以调用不了对应的方法
F.a()
//所有的原型最后都指向Object.prototype.可以调用
// 具体
// 先去找构造函数的隐式原型，即Function的显示原型：Function.prototype
//原型是个对象，其隐式原型会指向Object的显示原型
// 可以调用对应的方法
F.b()
//没什么好说的

// test2
var A = function() {};
A.prototype.n = 1;
// A.prototype.m = 5
var b = new A();
//在创建b这个实例的时候，所有b的属性已经固定了
A.prototype = {
  n: 2,
  m: 3
}
var c = new A();

console.log(b.n);
console.log(b.m);
//调用失败，为undefined,
//在创建这个实例时，原型上并没有这个属性
//每个对象固有的原型链 ，在创建对象时就已经确定，不会更改
console.log(c.n);
console.log(c.m);