创建对象

JavaScript中有两种最简单的创建对象的方式，一种是字面量，一种是通过Object构造函数，但是这两种方式有一个明显的缺点，就是会产生大量重复的代码。为了解决这一问题，使用者创建了其它抽象的方式来创建对象。

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

原理是用函数封装以特定参数来创建对象的过程，原理仍然是创建一个Object实例，为它赋予属性和方法，但是没有解决对象识别的问题，无法知道一个对象的类型。

2.构造模式

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

person1.sayName();   //"Nicholas"
person2.sayName();   //"Greg"

alert(person1 instanceof Object);  //true
alert(person1 instanceof Person);  //true
alert(person2 instanceof Object);  //true
alert(person2 instanceof Person);  //true

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

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

构造模式与工厂模式不同的之处在于：

• 没有显示的创建对象
• 直接将属性的方法赋给this对象
• 没有return

在自定义一个构造函数之后，要创建一个构造函数的实例，必须使用new操作符。这种方式调用构造函数时会经历以下过程：

• 创建一个新对象
• 将构造函数的作用于赋给新对象（因此this就指向了这个新对象）
• 执行构造函数中的代码（为这个新对象添加属性）
• 返回新对象
  然后创建的实例的原型对象有一个constructor属性指向构造函数，这样就解决了对象识别的问题（不过提到对象类型检测，还是instanceof更可靠）。
  构造函数与其他函数没有区别，只是调用的方式不一样，并且约定俗称的构造函数必须以大写字母开头。
  构造函数的调用方式不同会产生不一样的结果：
• new操作符调用，this被指向新的实例，相应方法属性也被绑定到新实例
• 普通方式调用，并且在全局作用域中调用，this指向window对象
• call（）或者apply（）调用，在某个对象O的作用域中调用，那么this指向这个对象，并且对象O拥有构造函数中定义的属性和方法。

而构造函数最大的问题在于创建新实例的时候，每个方法都要在实例上重新创建一遍。

3.原型模式

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

alert(Person.prototype.isPrototypeOf(person1));  //true
alert(Person.prototype.isPrototypeOf(person2));  //true

//only works if Object.getPrototypeOf() is available
if (Object.getPrototypeOf){
    alert(Object.getPrototypeOf(person1) == Person.prototype);  //true
    alert(Object.getPrototypeOf(person1).name);  //"Nicholas"
}

通过构造函数创建的每个实例都有一个prototype属性，这个属性是一个指针，指向构造函数的原型对象（这个连接在于实例与原型之间，而不是实例与构造函数之间），而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。使用这种模式创建的对象，不必在构造函数中定义对象实例的信息，而是将这些信息添加到原型对象中。
而有关对象原型又会是长篇大论，这里在另外的地方进行探讨JavaScript中的原型。
但是单独使用原型模式最大的问题在于，如果改变某个实例引用类型的值，这个改变会应用到所有实例中，因为引用类型的值存在于原型对象之中，所有实例的引用都共享这个特定的值。
所以要使用构造函数和原型模式来创建对象：
构造函数模式用于定义实例属性，原型模式用于定义方法和共享的属性。这样每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省内存。

4.Object.create

var o2={name:"o2"};
var o2_create=Object.create(o2);
console.log(o2_create)// 输出一个空对象 {}
console.log(o2_create.name)
//但是o2_create仍然可以访问到name属性 因为Object.create让o2_create的__proto__指向了o2

这个方式让传入Object.create的对象成为新对象的原型对象。

5.new方式构建对象和Object.create的区别

    function Func(name){
        this.name=name;
    }
    var o1=new Func("o1");
    console.log(o1);

new构建的对象.png

    var o2={name:"o2"};
    var o2_create=Object.create(o2);
    console.log(o2_create)// 输出一个空对象 {}

Object.create构建的对象.png

• 首先实现方式上不同

var o1 = new Object();
o1.__proto__= Func.prototype;
Func.call(o1);

在调用new时发生了以上过程，新建一个对象o1，并让o1的__proto__指向Func的prototype对象。然后使用call进行this绑定到o1，来实现实例对象的创建

Object.create =  function (o) {
    var F = function () {};
    F.prototype = o;
    return new F();
};

Object.create内部实现过程如上，新建一个构造函数，让构造函数的原型对象等于传入的对象o，然后返回一个由该构造函数创建的实例对象，这个对象本身是一个空对象，但是自身的__proto__与o发生了关联，它的__proto__就指向o，所以可以访问到o上面的对象。