js原型原型链

一. 普通对象与函数对象

javascript 中，万物皆对象！但对象也是有区别的。分为普通对象和函数对象，object 、function 是 js 自带的函数对象。

o1 o2 o3 为普通对象，f1 f2 f3 为函数对象  (凡是通过 new function() 创建的对象都是函数对象，其他的都是普通对象)

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

构造函数（扩展）

1.var a = {} 其实是 var a = new object()的语法糖  （a 的构造函数是 object 函数）

2.var a = [] 其实是 var a = new array()的语法糖    （a 的构造函数是 array 函数）

3.function foo(){...}其实是 var foo = new function(...)     （foo 的构造函数是 function 函数）

二. 构造函数

function person(name, age, job) {
 this.name = name;
 this.age = age;
 this.job = job;
 this.sayname = function() { alert(this.name) } 
}
var person1 = new person('zaxlct', 28, 'software engineer');
var person2 = new person('mick', 23, 'doctor');

person1 和 person2 都是 person 的实例，两个实例都有一个 constructor （构造函数）属性，该属性（是一个指针）指向 person，其层级如下：

所以可以得出：
 console.log(person1.constructor == person); //true
 console.log(person2.constructor == person); //true

person1 和 person2 都是 构造函数 person 的实例
实例的构造函数属性（constructor）指向构造函数

三. 原型对象

在 javascript 中，每当定义一个对象（函数也是对象）时候，对象中都会包含一些预定义的属性。其中每个函数对象都有一个prototype 属性（只有函数才有prototype，实例只有__proto__），这个属性指向函数的原型对象。

注意：

1.只有函数才有prototype，实例（new animal）只有__proto__

2.函数是function的实例，函数的prototype是object的实例

3.function.__proto__ == function.prototype

4.object.prototype.__proto__ == null

比如：

function animal() {}

const a = new animal()

1.     a.__proto__ == animal.prototype

2.    animal.prototype.constructor == animal 

3.    只要用function声明的animal，就会带一个prototype属性，而animal是function的实例 【animal instanceof function 为true】，animal.__proto__ == function.prototype

4.    animal.prototype是animal上一个属性，是一个对象属性，它【animal.prototype instanceof object 为true】，animal.prototype.__proto__ == object.prototype

四. 原型对象继承

  当我们声明一个function关键字的方法时，会为这个方法添加一个prototype属性，指向默认的原型对象，并且此prototype的constructor属性也指向方法对象

function person() {
}
var person = new person();
person 就是一个构造函数，我们使用 new 创建了一个实例对象 person

第一：
每个函数都有一个 prototype 属性
每一个javascript对象(null除外)在创建的时候就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型"继承"属性。

每一个javascript对象(除了 null )都具有的一个属性，叫proto，这个属性会指向该对象的原型

每个原型都有一个 constructor 属性指向关联的构造函数 实例原型指向构造函数

最终原型链

1）什么是原型链？

    原型链的核心就是依赖对象的_proto_的指向，当自身不存在的属性时，就一层层的扒出创建对象的构造函数，直至到object时，就没有_proto_指向了。

2）如何分析原型链?

    因为_proto_实质找的是prototype，所以我们只要找这个链条上的构造函数的prototype。其中object.prototype是没有_proto_属性的，它==null。

最简单的原型链分析

function person(name){
　　this.name = name;
}
var p = new person();
//p ---> person.prototype --->object.prototype---->null