js---原型与原型链

一、原型

1. 函数的prototype属性

每个函数都有自己的prototype属性，它默认指向一个空的Object对象（没有自定义的属性和方法），即原型对象。
原型对象中有一个属性constructor，指向函数对象。

2. 给原型对象添加属性和方法

作用：函数的所有实例对象自动拥有原型中的属性和方法。

console.log(Date.prototype, typeof Date.prototype);
function Fn() { }
console.log(Fn.prototype);

console.log(Date.prototype.constructor === Date); // true
console.log(Fn.prototype.constructor === Fn); // true

Fn.prototype.test = function() {
	console.log('test');
}
var fn = new Fn();
fn.test();

二、显示原型与隐式原型

1. 每个函数都有一个prototype，即显示原型（属性）。

2. 每个实例对象都有一个__proto__，称为隐式原型（属性）。

3. 对象的隐式原型的值为其对应的构造函数的显示原型的值。

函数的prototype属性：在定义函数时自动添加的，默认是一个空的Object对象（没有自定义的属性和方法）

对象的__proto__属性：创建对象是自动添加的，默认值为构造函数的prototype属性值

function Fn() { }
console.log(Fn.prototype);

var fn = new Fn();
console.log(fn.__proto__);

console.log(Fn.prototype === fn.__proto__); //true

三、原型链

访问一个对象的属性时：
（1）现在自身属性中查找，找到返回
（2）如果没有，再沿着__proto__这条链向上查找，找到返回
（3）如果最终没找到，返回undefined
别名：隐式原型链
作用：查找对象的属性（方法）

当 new 一个函数的时候会创建一个对象，『函数.prototype』 等于 『被创建对象.proto』

一切函数都是由 Function 这个函数创建的，所以『Function.prototype === 被创建的函数.proto』

一切函数的原型对象都是由 Object 这个函数创建的，所以『Object.prototype === 一切函数.prototype.proto』

function Fn() {
	this.test1 = function(){
		console.log('test1');
    }
}
Fn.prototype.test2 = function() {
	console.log('test2');
}
var fn = new Fn();
fn.test1();
fn.test2();
console.log(fn.toString());
fn.test3();

读取对象的属性时：会自动到原型链中查找；
设置对象的属性时：不会查找原型链，如果当前对象中没有该属性，直接添加此属性并设置其值；
方法一般定义在原型中，属性一般通过构造函数定义在对象本身上。

function Person(name, age) {
	this.name = name;
	this.age = age;
}
Person.prototype.setName = function(name) {
	this.name = name;
}
var p1 = new Person('Tom', 12);
p1.setName('Bob');

var p2 = new Person('Jack', 12);
p2.setName('Ann');

console.log(p1.__proto__ === p2.__proto__); // true

四、instance of

instance of 是如何判断的？

• 表达式：A instance of B
• 如果B函数的显示原型对象在A对象的原型链上，返回true，否则返回flase

五、测试题

测试题1：

function A() { }
A.prototype.n = 1;

var b = new A();

A.prototype = {
	n: 2,
	m: 3
}

var c = new A();

console.log(b.n, b.m, c.n, c.m); // 1, undefined, 2, 3

测试题2：

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

var f = new F();
f.a();
f.b();
F.a();
F.b();

console.log(Object.prototype);
console.log(Function.prototype):