使用工厂方法创建对象，构造函数，原型对象

一、使用工厂方法创建对象

创建一个对象

var obj = {
	name: "Lily",
	age: 19,
	gender: "女",
	sayName: function() {
		alert(this.name);
	}
};

var obj2 = {
	name: "Tom",
	age: 19,
	gender: "男",
	sayName: function() {
		alert(this.name);
	}
};

var obj3 = {
	name: "Amy",
	age: 19,
	gender: "女",
	sayName: function() {
		alert(this.name);
	}
};

obj.sayName();
obj2.sayName();
obj3.sayName();

这样就会发现不利于我们大批量的生产对象，希望我们创建对象的方式能够简单一点。我们发现在以上代码中存在大量重复的代码，我们就可以把重复的代码提取出来，提取到一个函数里，一个方法里，在使用的时候直接调用函数就可以了，下面使用工厂方法创建对象。

function createPerson(name, age, gender){
	//创建一个新对象
	var obj = new Object();
	//向对象中添加属性
	obj.name = name;
	obj.age = age;
	obj.gender = gender;
	obj.sayName = function(){
		alert(this.name);
	}
	//将新的对象返回
	return obj;
}

var obj2 = createPerson("Lily",19,"女");
var obj3 = createPerson("Tom",29,"男");
var obj4 = createPerson("Amy",26,"女");

console.log(obj2);
console.log(obj3);
console.log(obj4);

obj4.sayName("Jerry");

这种方法更方便我们批量创建对象，把属性传进去，返回对象，重复性的代码只写一次，不用再写很多次。虽然这种方式简单了，但是还是存在一些问题，刚才是创建了一个人的对象（createPerson），之后还可能需要创建狗的对象（createDog）。

function createPerson(name, age, gender){
	//创建一个新对象
	var obj = new Object();
	//向对象中添加属性
	obj.name = name;
	obj.age = age;
	obj.gender = gender;
	obj.sayName = function(){
		alert(this.name);
	}
	//将新的对象返回
	return obj;
}

var obj4 = createPerson("Amy",26,"女");

function createDog(name, age){
	//创建一个新对象
	var obj = new Object();
	//向对象中添加属性
	obj.name = name;
	obj.age = age;
	obj.sayHello = function(){
		alert("汪汪。。。");
	}
	//将新的对象返回
	return obj;
}

var dog = createDog("小花",3);

console.log(dog);
console.log(obj4);

这样会发现，不看名没办法判断哪个是人的对象，哪个是人的对象，因为他们都是Object，无法区分类。使用工厂方法创建的对象，使用的构造函数都是Object，所以创建的对象都是Object这个类型，就导致我们无法区分出多种不同类型的对象。

二、构造函数

我们发现，创建人的对象的时候是new Object()，创建狗的对象的时候也是new Object()，我们希望区分一下不同的类型，创建人的时候new Person()，创建狗的时候new Dog()，分别用不同的构造函数创建的，这样就区分开了。

构造函数就是一个普通的函数，创建方式和普通函数没有区别，不同的是构造函数习惯上首字母大写。

构造函数和普通函数的区别就是调用方式的不同，普通函数是直接调用，而构造函数需要使用new关键字来调用。

构造函数的执行流程：首先立刻创建一个新的对象；然后将新建的对象设置为函数中this，在构造函数中可以使用this来引用新建的对象；再然后逐行执行函数中的代码；最后将新建的对象作为返回值返回。

我们来创建两个构造函数，专门用来创建Person对象和Dog对象的。

function Person(name, age, gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = function(){
		alert(this.name);
	};
}

var per = new Person("Lily",20,"女");
console.log(per);
function Dog(name, age){
	this.name = name;
	this.age = age;
	this.sayHello = function(){
		alert("汪汪。。。");
	};
}

var dog = new Dog("小花",3);
console.log(dog);

使用同一个构造函数创建的对象，我们称为一类对象，也将一个构造函数称为一个类。我们将通过一个构造函数创建的对象，称为是该类的实例。则per是Person的实例，dog是Dog的实例。

运算符instanceof
使用instanceof可以检查一个对象是否是一个类的实例，如果是返回true，否则返回false。

console.log(per instanceof Person); //true
console.log(per instanceof Dog);	//false
console.log(dog instanceof Dog);	//true
console.log(dog instanceof Person);	//false

所有的对象都是Object的后代，所以任何对象和Object做instanceof检查时都会返回true。

console.log(per instanceof Object); //true
console.log(dog instanceof Object); //true

继续改进构造函数
还是像上面一样创建一个Person构造函数，在Person的构造函数中，为每一个对象都添加一个sayName方法，目前我们的方法是在内部创建的，也就是构造函数每执行一次就会创建一个新的sayName方法，也是所有实例的sayName都是唯一的。这样就导致了构造函数执行一次就会创建一个新的方法。而且这些方法都是一模一样的，我们完全可以使所有的对象共享同一个方法

function Person(name, age, gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = function(){
		alert(this.name);
	};
}

var per = new Person("Lily",20,"女");
var per2 = new Person("Tom",25,"男");
console.log(per.sayName == per2.sayName); //false

将sayName函数提取出来，放在全局作用域中，将这个函数赋值给sayName，这样即使构造函数执行了很多次，sayName还是这有一个。

function Person(name, age, gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = fun;
}
function fun(){
	alert(this.name);
};
var per = new Person("Lily",20,"女");
var per2 = new Person("Tom",25,"男");
console.log(per.sayName == per2.sayName); //true

三、原型对象

原型 prototype

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

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

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

function MyClass(){
}
MyClass.prototype.a = 123;
var mc = new MyClass();
console.log(mc.a); // 123
//先去mc中找a，mc中没有，则去原型对象中找，找到a并返回

//向mc中添加a属性
function MyClass(){
}
MyClass.prototype.a = 123;
var mc = new MyClass();
mc.a = "我是mc中的a";
console.log(mc.a); // 我是mc中的a

方法也是一样的。

之前的代码虽然一定程度上有所改进，但是这样写，将函数定义在全局作用域中，污染了全局作用域的命名空间，团队协作的时候，起名的时候可能会重名被覆盖掉。我们现在向原型中添加sayName方法。

function Person(name, age, gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
}

Person.prototype.sayName = function (){
	alert(this.name);
};

var per = new Person("Lily",20,"女");
var per2 = new Person("Tom",25,"男");
per.sayName();
per2.sayName();

这样既确保函数只有一个，又不会影响全局作用域。

以后我们创建构造函数的时候，可以将这些对象共有的属性和方法，统一添加到构造函数的原型对象中，这样不用分别为每一个对象添加，也不会影响到全局作用域，就可以使每个对象都具有这些属性和方法了。

运算符in
使用in检查对象中是否含有某个属性时。

如果对象中没有但是原型中有，也会返回true。这样就会有点问题，我们要想检查mc有没有自己的name，in就达不到要求，这时我们可以使用对象的hasOwnProperty()来检查对象自身中是否含有该属性。使用该方法只有当对象自身中含有该属性时，才会返回true。

function MyClass(){
}

MyClass.prototype.name = "我是原型中的name";
var mc = new MyClass();
mc.age = 18;
console.log(mc.name);
console.log("name" in mc); // true
console.log(mc.hasOwnProperty("name")); // false
console.log(mc.hasOwnProperty("age")); // true

那么这个hasOwnProperty()方法哪里来的？

console.log(mc.hasOwnProperty("hasOwnProperty")); //false

mc中也没有这个方法，那么这个方法就是在原型中。

console.log(mc.__proto__.hasOwnProperty("hasOwnProperty")); // false

这时会发现，这个方法也不在原型中。原型对象也是个对象，那么原型对象也有原型。当在使用一个对象的属性或方法时，会先在自身中寻找，自身中有则直接使用；自身中如果没有，则在原型对象中找，原型对象中有则使用，如果没有，则去原型的原型中找。

console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty")); // true

那如果原型的原型中没有，那就去原型的原型的原型中去找，那这样就没完没了了。那么找到什么时候呢？

console.log(mc.__proto__.__proto__.__proto__); // null

一层一层往上找，直到找到Object对象的原型，Object对象的原型没有原型，如果在Object中依然没有找到，则返回undefined。