JavaScript中创建对象的方式有很多种，下面对这些方法进行分析和优缺点对比。
Object构造函数
var person = new Object();
person.name = "Hysunny";
缺点： 使用同一个接口创建很多对象，会产生大量的重复代码。
对象字面量
var person = {
name: "Hysunny"
}
缺点： 同Object构造函数。使用同一个接口创建很多对象，会产生大量的重复代码。
Object.create 方式
Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象。
var Person = {
name: "Hysunny",
sayName: function() {
console.log(this.name);
}
}
var person1 = Object.create(Person);
var person2 = Object.create(Person);
person1.sayName(); // "Hysunny"
console.log(person1.sayName === person2.sayName); // true
优点： 单例继承，语法简单。
缺点： 封装性不好，多实例需要重复初始化过程。
工厂模式
function createPerson(name) {
var o = new Object();
o.name = name;
o.sayName = function () {
console.log(this.name);
}
return o;
}
var person1 = createPerson("Hysunny");
var person2 = createPerson("Max");
优点： 实现函数封装，无数次调用，都返回一个对象。
缺点： 无法识别对象，因为所有实例的constructor都指向Object。
构造函数模式
构造函数：通过
new关键字方式调用的函数。在构造函数内部 - 也就是被调用的函数内 -
this指向新创建的对象Object。 这个新创建的对象的prototype被指向到构造函数的prototype。
如果被调用的函数没有显式的 return 表达式，则隐式的会返回 this 对象 - 也就是新创建的对象。
function Person(name) {
this.name = name;
this.sayName = function() {
console.log(this.name);
};
}
var person1 = new Person("Hysunny");
var person2 = new Person("Max");
console.log(person1.sayName === person2.sayName) // false
优点： 通过constructor或者instanceof可以识别对象实例的类别。
缺点： 浪费内存。每个方法都要在每个实例上重新创建一遍。
原型模式
原型（prototype）：每个函数对象都有一个
prototype属性，这个属性指向函数的原型对象。原型对象（Person.prototype）是 构造函数（Person）的一个实例。
function Person() {}
Person.prototype.name = "Hysunny";
Person.prototype.sayName = function() {
console.log(this.name)
}
var person1 = new Person();
person1.sayName(); // Hysunny
var person2 = new Person();
person2.sayName(); // Hysunny
console.log(person1.sayName === person2.sayName) // true
优点：
- 通过
prototype添加的属性和方法所有实例共享 - 可以动态的添加原型对象的属性和方法，并直接反映到实例上
缺点：
- 实例无法重写原型中的值
- 访问实例的某个属性时，会先搜索
对象实例本身，如果对象实例中具有给定名字的属性，则返回该属性的值；如果没有找到，则继续搜索指针指向的原型对象，如果在原型对象中找到该属性，则返回该属性的值。
构造函数和原型的组合模式
构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。
function Person(name) {
this.name = name;
this.friends = ["Jasper", "Cindy"];
}
Person.prototype = {
constructor: Person, // 手动将constructor指向Person，否则constructor将指向Object
sayName: function() {
console.log(this.name);
}
}
var person1 = new Person("Hysunny");
var person2 = new Person("Max");
person1.friends.push("Ann");
console.log(person1.friends); // ["Jasper", "Cindy", "Ann"]
console.log(person2.friends); // ["Jasper", "Cindy"]
console.log(person1.friends === person2.friends); // false
console.log(person1.sayName === person2.sayName); // true
优点：
是使用最广泛、认同度最高的一种创建自定义类型的方法。
- 每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法引用，最大限度地节省了内存；
- 支持向构造函数传递参数。
缺点： 缺乏更好的封装性。
动态原型模式
动态原型模式将所有信息都封装在了构造函数中，初始化的时候，通过检测某个应该存在的方法时候有效，来决定是否需要初始化原型。
function Person(name) {
// 属性
this.name = name;
// 方法
if (typeof this.sayName !== "function") {
Person.prototype.sayName = function() {
console.log(this.name);
}
}
}
var person = new Person("Hysunny");
person.sayName();
优点：
- 仅在需要的时候初始化原型，节省内存；
- 对原型所做的修改，都能够立即在所有的实例中得到反映。
缺点： — —
注意：
使用动态原型模式时，不能使用对象字面量重写原型。因为，如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系。
寄生构造模式
function Person(name) {
var o = new Object();
o.name = name;
o.sayName = function() {
console.log(this.name);
};
return o;
}
var person = new Person("Hysunny");
person.sayName(); // "Hysunny"
优点：
在上面的几种模式都不适用的时候，可以使用该方法。比如：创建一个具有额外方法的特殊数组，由于不能直接修改Array构造函数，可以使用这个模式。
function SpecialArray() {
// 创建数组
var array = new Array();
// 添加值
array.push.apply(array, arguments);
// 添加方法
array.toPipedString = function() {
return this.join(" | ");
};
// 返回数组
return array;
}
var colors = new SpecialArray("red", "blue", "green");
console.log(colors.toPipedString()); // "red | blue | green"
缺点：
无法使用instanceof来识别对象所属类型
稳妥构造函数模式
稳妥对象(durable objects):
- 没有公共属性，而且其方法也不引用
this的的对象；- 最适合在一些安全的环境中（这些环境中会禁止使用
this和new），或者在防止数据被其他应用程序改动时使用。
稳妥构造函数和寄生构造函数的区别：
- 新创建对象的实例方法不引用
this；- 不适用
new操作符调用构造函数。
function Person(name) {
// 创建要返回的对象
var o = new Object();
// 可以在这里定义私有变量和函数
// 添加方法
o.sayName = function() {
console.log(name)
};
// 返回对象
return o;
}
var person = new Person("Hysunny");
person.sayName();
优点： 非常适合在某些安全执行环境下使用。
缺点： 无法使用instanceof来识别对象所属类型
参考：
《JavaScript 高级程序设计》 第三版
