一、工厂模式

工厂模式解决了创建多个相似对象的问题，但却没有解决对象识别的问题——即知道一个对象的类型

 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("Nicholas", 29, "Software Engineer");
 var person2 = createPerson("Greg", 27, "Doctor");

二、构造函数模式

function Person(name, age, job) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.sayName = function () {
          alert(this.name);
        };
      }
      var person1 = new Person("Nicholas", 29, "Software Engineer");
      var person2 = new Person("Greg", 27, "Doctor");

2.1 和工厂函数的区别：

1. 没有显示的创建对象
2. 直接将属性和方法赋给了this对象
3. 没有return语句
4. 函数名首字母大写

创建Person的新实例，必须用new操作符。以这种方式调用构造函数实际上会经历以下4个步骤：

1. 创建一个新对象
2. 将构造函数的作用域赋值给新对象（因此this就指向了这个新对象）
3. 执行这个构造函数中的代码（为这个新对象添加属性）
4. 返回新对象

这里例子中person1和person2分别保存着Person的一个不同的实例。这两个对象都有一个constructor（构造函数）属性，该属性指向Person

alert(person1.constructor == Person) // true
alert(person2.constructor == Person) // true

对象的constructor属性最初是用来标识对象类型的。但是检测对象类型，还是instanceof更可靠。

创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型。这正是构造函数胜过工厂模式的地方。

2.2 构造函数和普通函数的区别

构造函数和其他函数唯一的区别，就在于调用它们的方式不同。任何函数，只要通过new操作符调用，那它就可以作为构造函数；而任何函数，如果不通过new操作符来调用，那它和普通函数也不会有什么两样。

// 当做构造函数使用
var person = new Person("Nicholas",29,"Software Engineer")
person.sayName(); //"Nicholas"

// 作为普通函数调用
Person("Greg",27,"Doctor") // 添加到window
window.sayName(); //"Greg"

// 在另一个对象的作用域中调用
var o = new Object();
Person.call(o,"Kristen",25,"Nurse")
o.sayName();  //"Kristen"

2.3 构造函数的问题

每个方法都要在每个实例上重新创建一遍。可以通过在全局作用域中创建函数解决这一问题，但这样让引用类型没有封装性。

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

 function sayName() {
   alert(this.name);
 }
 var person1 = new Person("Nicholas", 29, "Software Engineer");
 var person2 = new Person("Greg", 27, "Doctor");
 console.log(person1, person2);

三、原型模式

我们创建的每个函数都有一个`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();

var person2 = new Person();
person2.sayName();

alert(person1.sayName == person2.sayName);

3.1 理解原型对象

无论什么时候，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会自动获得一个constructor（构造函数）属性，这个属性包含一个指向prototype属性所在函数的指针。

1. 原型对象的缺点
   原型中所有属性是被很多实例共享，这种共享对于函数非常合适。对于包含基本值的属性也可以，对于包含引用类型的属性来说，可能会被修改。

function Person() {}

Person.prototype = {
  constructor: Person,
  name: "Nicholas",
  age: 29,
  job: "Software Engineer",
  friends: ["Shelby", "Court"],
  sayName: function () {
    alert(this.name);
  },
};

var person1 = new Person();
var person2 = new Person();

person1.friends.push("Van");

alert(person1.friends); // "Shelby,Court,Van"
alert(person2.friends); // "Shelby,Court,Van"
alert(person1.friends === person2.friends); // true

四、组合使用构造函数模式和原型模式

构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果每个实例都会有自己的一份实例属性的副本，但同时又共享者对方付的引用，最大限度地节省了内存。

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("Greg", 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

五、动态原型模式

可以将所有信息封装在构造函数中。

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 friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"

使用动态模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新实例之间的联系

六、寄生构造函数模式

通常，在前述几种模式都不适用的情况下，可以使用寄生构造函数模式。这种模式的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；

 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 friend = new Person("Nicholas", 29, "Software Engineer");
 friend.sayName(); //"Nicholas"

例如：

function SpecialArray() {
  // 创建数组
  var values = new Array();

  //添加值
  values.push.apply(values, arguments);

  //添加方法
  values.toPipedString = function () {
    return this.join("|");
  };

  //返回数组
  return values;
}

var colors = new SpecialArray("red", "green", "blue");
alert(colors.toPipedString());

返回的对象与在构造函数外部创建的对象没什么不同

七、稳妥构造函数模式

所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。

与寄生构造函数的区别：

1. 创建对象的实例方法不引用this
2. 不使用new操作符调用构造函数

function Person(name, age, job) {
  // 创建要返回的对象
  var o = new Object();

  //添加方法
  o.sayName = function () {
    alert(name);
  };

  // 返回对象
  return o;
}

var friend = Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"