JavaScript深入理解 —— 创建对象的方式

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

优点：

1. 通过prototype添加的属性和方法所有实例共享
2. 可以动态的添加原型对象的属性和方法，并直接反映到实例上

缺点：

1. 实例无法重写原型中的值
2. 访问实例的某个属性时，会先搜索对象实例本身，如果对象实例中具有给定名字的属性，则返回该属性的值；如果没有找到，则继续搜索指针指向的原型对象，如果在原型对象中找到该属性，则返回该属性的值。

构造函数和原型的组合模式

构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。

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

优点：

是使用最广泛、认同度最高的一种创建自定义类型的方法。

1. 每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法引用，最大限度地节省了内存；
2. 支持向构造函数传递参数。

缺点： 缺乏更好的封装性。

动态原型模式

动态原型模式将所有信息都封装在了构造函数中，初始化的时候，通过检测某个应该存在的方法时候有效，来决定是否需要初始化原型。

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();

优点：

1. 仅在需要的时候初始化原型，节省内存；
2. 对原型所做的修改，都能够立即在所有的实例中得到反映。

缺点： — —

注意：

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

寄生构造模式

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):

1. 没有公共属性，而且其方法也不引用this的的对象；
2. 最适合在一些安全的环境中（这些环境中会禁止使用this和new），或者在防止数据被其他应用程序改动时使用。

稳妥构造函数和寄生构造函数的区别：

1. 新创建对象的实例方法不引用this；
2. 不适用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 高级程序设计》 第三版

Object.create()