最近一直在看JS高级程序设计这本书，有空来梳理一下几种创建对象的方式。话不多说，直接步入正题。

第一种：Object构造函数创建

1 2 3

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

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

第二种：使用对象字面量表示法

1 2 3 4 5

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

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

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

第三种：使用工厂模式创建对象

1 2 3 4 5 6 7 8 9 10 11 12

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函数中，返回的是一个对象。那么我们就无法判断返回的对象究竟是一个什么样的类型。于是就出现了第四种创建对象的模式。

第四种:使用构造函数创建对象

1 2 3 4 5 6 7 8 9 10

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操作符，我们来进行自主检测：

1 2 3 4

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

同时我们也应该明白，按照惯例，构造函数始终要应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。

那么构造函数确实挺好用的，但是它也有它的缺点：

就是每个方法都要在每个实例上重新创建一遍，方法指的就是我们在对象里面定义的函数。如果方法的数量很多，就会占用很多不必要的内存。于是出现了第五种创建对象的方法

第五种：原型创建对象模式

1 2 3 4 5 6 7 8 9

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(); person1.sayName();

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

如果是使用原型创建对象模式，请看下面代码：

1 2 3 4 5 6 7 8 9 10 11 12

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' --来自原型

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

这时候我们就可以使用构造函数模式与原型模式结合的方式，构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性

第六种：组合使用构造函数模式和原型模式

1 2 3 4 5 6 7 8 9 10 11 12

function Person(name,age,job){  this.name =name;  this.age = age;  this.job = job; } Person.prototype = {  constructor:Person,  sayName: function(){  alert(this.name);  }; } var person1 = new Person('Nike',20,'teacher');

创建 例子上面回答有；

（1）第一种是工厂模式，工厂模式的主要工作原理是用函数来封装创建对象的细节，从而通过调用函数来达到复用的目的。但是它有一个很大的问题就是创建出来的对象无法和某个类型联系起来，它只是简单的封装了复用代码，而没有建立起对象和类型间的关系。
（2）第二种是构造函数模式。js 中每一个函数都可以作为构造函数，只要一个函数是通过 new 来调用的，那么我们就可以把它称为构造函数。执行构造函数首先会创建一个对象，然后将对象的原型指向构造函数的 prototype 属性，然后将执行上下文中的 this 指向这个对象，最后再执行整个函数，如果返回值不是对象，则返回新建的对象。因为 this 的值指向了新建的对象，因此我们可以使用 this 给对象赋值。构造函数模式相对于工厂模式的优点是，所创建的对象和构造函数建立起了联系，因此我们可以通过原型来识别对象的类型。但是构造函数存在一个缺点就是，造成了不必要的函数对象的创建，因为在 js 中函数也是一个对象，因此如果对象属性中如果包含函数的话，那么每次我们都会新建一个函数对象，浪费了不必要的内存空间，因为函数是所有的实例都可以通用的。
（3）第三种模式是原型模式，因为每一个函数都有一个 prototype 属性，这个属性是一个对象，它包含了通过构造函数创建的所有实例都能共享的属性和方法。因此我们可以使用原型对象来添加公用属性和方法，从而实现代码的复用。这种方式相对于构造函数模式来说，解决了函数对象的复用问题。但是这种模式也存在一些问题，一个是没有办法通过传入参数来初始化值，另一个是如果存在一个引用类型如 Array 这样的值，那么所有的实例将共享一个对象，一个实例对引用类型值的改变会影响所有的实例。
（4）第四种模式是组合使用构造函数模式和原型模式，这是创建自定义类型的最常见方式。因为构造函数模式和原型模式分开使用都存在一些问题，因此我们可以组合使用这两种模式，通过构造函数来初始化对象的属性，通过原型对象来实现函数方法的复用。这种方法很好的解决了两种模式单独使用时的缺点，但是有一点不足的就是，因为使用了两种不同的模式，所以对于代码的封装性不够好。
（5）第五种模式是动态原型模式，这一种模式将原型方法赋值的创建过程移动到了构造函数的内部，通过对属性是否存在的判断，可以实现仅在第一次调用函数时对原型对象赋值一次的效果。这一种方式很好地对上面的混合模式进行了封装。
（6）第六种模式是寄生构造函数模式，这一种模式和工厂模式的实现基本相同，我对这个模式的理解是，它主要是基于一个已有的类型，在实例化时对实例化的对象进行扩展。这样既不用修改原来的构造函数，也达到了扩展对象的目的。它的一个缺点和工厂模式一样，无法实现对象的识别。

1。字面量创建
var obj = {
    name:"web",
    eat:function(){}
}
缺点：代码冗余，适合单个对象创建

2.实例创建
var obj = new Object();
obj.name = "web";
obj.eat = function(){}
缺点：代码冗余，适合单个对象创建

3.工厂模式创建
function createObj(name){
    var obj = new Object();
    obj.name = name;
    obj.eat = function(){}
    return obj
}
createObj(“web”);
缺点：识别不明确

4.构造函数创建
function Student(name){
    //new Object
    this.name = name;
    this.eat = function(){}
}
new Student(name)
缺点：浪费内存

5.原型创建
原型对象：prototype ，构造函数中，共享的一块区域
原型属性：__proto__,实例对象中，指向原型对象
function Student(){}
Student.prototype.name = "web";
Student.prototype.eat = function(){}

new Student();
缺点：不能传参

6.混合创建，构造函数(可变的)+原型(共享，不变的)
function Student(name){
    this.name = name;
}
Student.prototype.eat = function(){

}

“JavaScript创建对象的方法：1、使用new关键字，通过“构造函数”方式创建对象。2、使用Object直接创建对象。3、通过”字面量“方式创建。4、原型模式创建对象。5、使用工厂模式创建对象。”