创建对象的多种方式

1.object的构造函数创建

var Person = new Object();
Person.name = 'Nike';
Person.age = 29;

这行代码创建了Object引用类型的一个新实例，然后把实例保存在变量Person中。

2. 使用对象字面量表示法

var Person = {};//相当于var Person = new Object();
var Person = {
 name:'Nike';
 age:29;  
}

对象字面量是对象定义的一种简写形式，目的在于简化创建包含大量属性的对象的过程。也就是说，第一种和第二种方式创建对象的方法其实都是一样的，只是写法上的区别不同

在介绍第三种的创建方法之前，我们应该要明白为什么还要用别的方法来创建对象，也就是第一种，第二种方法的缺点所在：它们都是用了同一个接口创建很多对象，会产生大量的重复代码，就是如果你有100个对象，那你要输入100次很多相同的代码。那我们有什么方法来避免过多的重复代码呢，就是把创建对象的过程封装在函数体内，通过函数的调用直接生成对象。

3.工厂模式

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('Nike',29,'teacher');
var person2 = createPerson('Arvin',20,'student');

在使用工厂模式创建对象的时候，我们都可以注意到，在createPerson函数中，返回的是一个对象。那么我们就无法判断返回的对象究竟是一个什么样的类型。于是就出现了第四种创建对象的模式。

4.使用构造函数创建对象

解决问题：解决对象识别的问题（即怎样知道一个对象的类型） 

构造函数始终要应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。

function Person(name,age,job){
 this.name = name;
 this.age = age;
 this.job = job;
 this.sayName = function(){
 alert(this.name);
 }; 
}
var person1 = new Person('Nike',29,'teacher');
var person2 = new Person('Arvin',20,'student');

对比工厂模式，我们可以发现以下区别：

1.没有显示地创建对象

2.直接将属性和方法赋给了this对象

3.没有return语句

4.终于可以识别的对象的类型。对于检测对象类型，我们应该使用instanceof操作符，我们来进行自主检测：

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

缺点：

每个方法都要在每个实例上重新创建一遍，person1和person2都有一个sayName()的方法，但两个方法不是同一个Function实例。不同实例上的同名函数是不相等的。

创建两个完成同样任务的Function实例没有必要，而且还有this对象在，不需要在执行代码前就把函数绑定在特定对象上，可以像下面这样。

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

把sayName属性设置成全局的sayName函数，这样，由于sayName包含的是一个指向函数的指针，因此person1和person2对象就共享了同一个函数。 

但是，如果对象需要定义很多方法，那么就要定义很多全局函数，自定义的引用类型也没有封装可言了,就会占用很多不必要的内存。为了解决上述问题，引入原型模式。

5.原型创建对象模式

我们创建的每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。prototype是通过调用构造函数而创建的那个对象实例的对象原型，使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。 

解决的问题: 
1.不必再构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象(prototype)中。 

2.使用原型创建对象的方式，可以让所有对象实例共享它所包含的属性和方法。

function Person(){}
Person.prototype.name = 'Nike';
Person.prototype.age = 20;
Person.prototype.jbo = 'teacher';
Person.prototype.sayName = function(){
 alert(this.name);
};
var person1 = new Person();
var person2 = new Person();
person1.name ='Greg';
alert(person1.name); //'Greg' --来自实例
alert(person2.name); //'Nike' --来自原型  

当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中保存的同名属性

function Person(){}  
Person.prototype = {  
        constructor : Person,  
        name : "Nicholas",  
        age : 29,  
        sayName : function(){alert(this.name);},  
        friends : ["goser" , "greg"]  
};  
var person1 = new Person();  
var person2 = new Person();  
person1.friends.push("gat");  
alert(person1.friends);//"goser,greg,gat"  
alert(person2.friends);//"goser,greg,gat"  
alert(person1.friends == person2.friends);//true  

本意只想修改person1的friends，但是却导致person2的friends属性值也改变了。因此我们很少单独使用原型模式。

原型对象的问题 :

原型模式最大问题是由其共享的本性所导致的。 

对于包含引用类型值的属性来说，问题较为突出 

6.组合使用构造函数模式和原型模式

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

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,Count,van"
alert(person2.friends);     //"Shelby,Count"
alert(person1.friends === person2.friends);    //false
alert(person1.sayName === person2.sayName);   //true