构造函数，原型对象，实例化对象的关系：
- 每个函数（包括构造函数）都有一个原型对象（prototype）
- 原型对象都包含一个指向构造函数的指针（constructor）
- 原型对象上的属性和方法，都可以被构造函数的实例化对象所继承（所有实例化对象共享一个原型对象）
- 实例化对象又都包含一个指向构造函数的原型对象的内部指针(__proto__)，（p1.__proto__ === Person.prototype）（p1.__proto__.constructor === Person.prototype.constructor）（p1.__proto__.constructor === Person）
- 实例化对象的 constructor 属性指向构造函数（p1.constructor === Person）
prototype 是函数才有的属性，切记，切记
__proto__ 是每个对象(包括函数)都有的属性
1.工厂模式
function createPerson(name, age, job){
var o = new Object(); // "原料"
// "加工"
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o; // "出厂"
}
var person1 = createPerson("a1", 12, "程序");
var person2 = createPerson("b1", 18, "销售");
console.log(person1.name) // a1
console.log(person2.age) // 18
2.构造函数模式
构造函数，是用来创建对象的函数，本质上也是函数
任何函数，只要通过 new 操作符来调用，那它就可以作为构造函数 ；
任何函数，如果不通过 new 操作符来调用，那它跟普通函数也没有什么两样。
// 创建函数
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
}
}
// 当作构造函数使用
var person = new Person('Nicholas', 29, 'Software Engineer'); // this --> person
person.sayName(); // 'Nicholas'
这里的 Person 就称为构造函数，person 称为 Person 函数对象的一个实例（复制品）
// 当作普通函数调用
Person('Greg', 27, 'Doctor'); // this --> window
window.sayName(); // 'Greg'
“构造函数模式” 与 “工厂模式” 对比
* 1、没有显式地创建对象
* 2、直接将属性和方法赋给了 this 对象
* 3、没有 return 语句
* 4、构造函数都应该以 一个大写字母开头 function Person(){...}，而非构造函数则应该以一个小写字母开头 function person(){...}
* 5、使用 new 创建对象
* 6、能够识别对象（这正是构造函数模式胜于工厂模式的地方）
构造函数模式的问题
使用构造函数的主要问题就是每个方法都要在每个实例上重新创建一遍
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
}
}
var person1 = new Person();
var person2 = new Person();
person1 和 person2 都有一个名为 sayName() 的方法，但是这两个方法不是同一个 Function 的实例
console.log(person1.sayName == person2.sayName) // false
然而，创建两个完成同样任务的 Function 实例的确没有必要，大可像下面这样，通过把函数定义转移到构造函数外部来解决这个问题
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = sayName;
}
function sayName (){
alert(this.name);
}
console.log(person1.sayName == person2.sayName) // true
在这个例子中，我们把 sayName() 函数的定义转移到了构造函数外部。而在构造函数内部，我们将 sayName 属性设置成等于全局的 sayName 函数。这样一来，由于 sayName 包含的是一个指向函数的指针，因此 person1 和 person2 对象就共享了在全局作用域中定义的同一个 sayName() 函数。这样做确实解决了两个函数做同一件事的问题，可是新问题又来了：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不副实。而更让人无法接受的是：如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。好在这些问题可以通过使用原型模式来解决。
3.原型模式
在 JS 中，无论什么时候，只要你创建了一个新函数，就会根据一组特定的规定为该函数创建一个 prototype 的属性，这个属性指向函数的原型对象。而在默认情况下，所有的原型对象都会自动获得一个 constructor (构造函数)属性，这个属性包含一个指向 prototype 属性所在函数的指针
使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法，换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中
function Person(){}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
alert(this.name);
};
var person1 = new Person();
person1.sayName(); // "Nicholas"
var person2 = new Person();
person2.sayName(); // "Nicholas"
alert(person1.sayName == person2.sayName); // true
在此，我们将 sayName() 方法和所有属性直接添加到了 Person 的 prototype 属性中，构造函数变成了空函数。与构造函数模式不同的是，新对象的这些属性和方法是由所有实例共享的。换句话说，person1 和 person2 访问的都是同一组属性和同一个 sayName() 函数
虽然可以通过对象实例访问保存在原型中的属性和方法，但却不能通过对象实例重写原型中的属性和方法（可以通过对象的 __proto__ 重写）
如果我们在实例中添加了一个属性和方法，而该属性和方法与实例原型中的同名，那我们就在实例中创建该属性和方法，该属性和方法将会屏蔽原型中的那个属性和方法
function Person(){}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
alert(this.name);
};
var person1 = new Person();
var person2 = new Person();
person1.name = "Grag";
person1.sayName = function(){
alert(this.age);
};
alert(person1.name); // "Grag"---来自实例
person1.sayName(); // "29"---来自实例
alert(person2.name); // "Nicholas"--来自原型
person2.sayName(); // "Nicholas"---来自原型
通过使用 delete 操作符可以完全删除实例属性
var person1 = new Person();
var person2 = new Person();
person1.name = "Grag";
alert(person1.name); // "Grag"---来自实例
alert(person2.name); // "Nicholas"--来自原型
delete person1.name;
alert(person1.name); // "Nicholas"--来自原型
通过使用 hasOwnProperty() 方法，可以检测一个属性是存在实例中，还是存在于原型中
alert(person1.hasOwnProperty("name")); // false
alert(hasPrototypeProperty("person", "name")); // true
person1.name = "Grag";
alert(person1.name); // "Grag"---来自实例
alert(person1.hasOwnProperty("name")); // true
alert(hasPrototypeProperty("person", "name")); // false
alert(person2.name); // "Nicholas"--来自原型
alert(person2.hasOwnProperty("name")); // false
delete person1.name;
alert(person1.name) // "Nicholas"--来自原型
alert(person1.hasOwnProperty("name")); // false
更简单的原型写法
用一个包含所有属性和方法的对象字面量来重写整个原型对象
function Person(){}
Person.prototype = {
// 由于字面量写法，等于以一个字面量形式创建的新对象，本质上完全重写了默认的 prototype 对象，
// 导致 constructor （构造函数的指针）不再指向 Person 了，
// 因此 constructor 属性也就变成了新对象的 constructor 属性（指向 Object 构造函数），所以我们需要特意将它设置适当的值
constructor: Person,
name: "Nicholas",
age: 29,
job: "Software Engineer",
sayName: function(){
alert(this.name);
}
}
var person1 = new Person();
alert(person1.name) // "Nicholas"
原型对象的问题
首先它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值，但还不是原型的最大问题，其实最大的问题还是原型中所有属性是被很多实例共享的，这种共享对于函数非常合适。对于那些包含基本值的属性倒也说得过去，毕竟通过在实例上添加一个同名属性，可以隐藏原型中的对应属性。然而，对于包含引用类型值的属性来说，就有问题了---全部共享一个属性(无论怎样修改，其他实例的值都是一样的)
4.混合模式（组合使用构造函数模式和原型模式）
构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性，结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方方法的引用，这种混成模式还支持向构造函数传递参数
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ["Shelby", "Court"];
}
Person.prototype = {
constructor: Person,
sayName: function(){
alert(this.name);
}
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Grag", 27, "Doctor");
person1.friends.push("Van");
alert(person1.friends); // Shelby,Court,Van
alert(person2.friends); // Shelby,Court
alert(person1.friends === person2.friends); // false
alert(person1.sayName === person2.sayName); // true
这种构造函数与原型混成的模式，是目前在 ECMAScript 中使用最广泛，认同度最高的一种创建自定义类型的方法。可以说，这是用来定义引用类型的一种默认模式
5.动态原型模式
有其他 OO 语言经验的开发人员在看到独立的构造函数和原型时，很可能会感到非常困惑。动态原型模式正是致力于解决这个问题的一个方案，它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型(仅在必要的情况下)，又保持了同时使用构造函数和原型的优点。换句话说，可以通过检香某个应该存在的方法是否有效，来决定是否需要初始化原型
function Person(name, age, job){
//属性
this.name = name;
this.age = age;
this.job = job;
//方法
if(typeof this.sayName != "function"){
Person.prototype.sayName = function(){
alert(this.name);
}
}
}
var person = new Person("Nicholas", 29, "Software Engineer");
person.sayName();
这里只在 sayName() 方法不存在的情况下，才会将它添加到原型中。这段代码只会在初次调用构造函数时才会执行。此后，原型已经完成初始化，不需要在做什么修改了。
使用动态原型模式时，不能使用对象字面量重写原型。
6.寄生构造函数模式
类似于工厂模式与构造函数模式结合体
function Person(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o;
}
var person = new Person("Nicholas", 29, "Software Engineer");
person.sayName(); // "Nicholas"
构造函数在不返回值的情况下，默认会返回新对象的实例。而通过在构造函数的末尾添加一个 return 语句，可以重写调用构造函数时返回的值
7.稳妥构造函数模式
所谓稳妥对象，指的是没有公共属性，而且其方法也不引用 this 对象，不使用 new 操作符调用构造函数，稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用 this 和 new），或者在防治数据被其他应用程序改动时使用
function Person(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o;
}
var person = Person("Nicholas", 29, "Software Engineer");
person.sayName(); // "Nicholas"
这种模式创建的对象中，除了使用 sayName() 方法之外，没有其他办法访问 name 的值
