JS原型对象

引入：我们先用构造函数来创建一个对象

function Student(name,age,gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = function(){
		console.log(this.name);
	};
}
var stu = new Person("孙悟空",500,"男");
1
2
3
4
5
6
7
8
9

在构造内部创建一个sayName方法，由于构造函数每执行一次就会创建一个新的sayName方法，当创建的对象较多时，这样做不利于性能优化，所以我们考虑下面这种写法。

function Student(name,age,gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = fun;
}
function fun(){
	console.log(this.name);
}
var stu = new Person("孙悟空",500,"男");
1
2
3
4
5
6
7
8
9
10

将sayName方法定义在全局，就避免了上面所说的问题，这样所有实例化的对象用的都是同一个方法。但是这样做又带来了新的问题，将函数定义在全局作用域，污染了全局作用域的命名空间，而且在实际开发中将方法暴露在全局作用域也不安全。

下面我们来引入原型的概念。
我们创建的每一个函数，解析器都会向函数中添加一个属性prototype，这个属性对应着一个对象，这个对象就是原型对象。
如果函数作为普通函数调用prototype没有任何作用。
当函数以构造函数的形式调用时，它所创建的对象中都会有一个隐含的属性，指向该构造函数的原型对象，可以通过__proto__来访问该属性

function Test1(){
}
function Test2(){
}
var test11 = new Test1();
console.log(Test1.prototype == Test2.prototype);//false
console.log(Test1.prototype == test11.__proto__);//true
1
2
3
4
5
6
7

原型对象就相当于一个公共的区域，所有同一个类的实例都可以访问到这个原型对象。所以，可以将对象中共有的内容统一设置到原型对象中。

当我们访问对象的一个属性或方法时，它会先在对象自身中寻找，如果有则直接使用，如果没有则会去 原型对象中寻找。

function Test1(){
}
function Test2(){
}
var test11 = new Test1();
Test.prototype.name = "我是原型中的名字"
console.log(test11.name);//我是原型中的名字
1
2
3
4
5
6
7

function Test1(){
}
function Test2(){
}
var test11 = new Test1();
Test.prototype.name = "我是原型中的名字"
test11.name = "我是实例中的名字";
console.log(test11.name);//我是实例中的名字
1
2
3
4
5
6
7
8

原型对象也是对象，所以它也有原型
当我们使用一个对象的属性或方法时，会先在自身中寻找
自身中如果有，则直接使用，如果没有则去原型对象中寻找，如果原型对象中有，则使用；如果没有则去原型的原型中寻找,直到找到Object对象的原型。Object对象的原型没有原型，如果在Object中依然没有找到，则返回undefined。