使用字面量可以创建对象，但是使用一个借口创建多个对象会产生很多重复的代码，可以使用工厂模式进行解决。

一、工厂模式

      function createPerson(name,age){//new一个对象var o = new Object();//对象的属性o.name = name;o.age = age;//对象的方法o.sayName = function(){console.log(this.name);};//返回这个对象return o}//对象实例化var person1 = createPerson('ll',20)var person2 = createPerson('ww',21)person1.sayName();  //ll

函数createPerson()能够根据接受到的参数来构建一个包含所有必要信息的Person对象。可以无数次的调用这个函数，而每次它都会返回一个包含两个属性和一个方法的对象。
缺点：工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型)。

二、构造函数模式

使用构造函数可以用来创建特定类型的对象（构造函数的函数名以大写字母开头）：

function Person(name,age,job){this.name= name;this.age = age;this.job = job;this.sayName = function(){alert(this.name);}
}//person1和person2分别保存着Person不同的实例
var person1 = new Person('ll',19,'student');
var person2 = new Person('ww',21,'web');

此方法书写的代码与工厂模式的不同在于：
1.没有显式的创建对象
2.直接将属性和方法赋给了this对象
3.没有return语句
要创建构造函数Person的实例，必须使用new操作符，需要经历以下步骤：
1.创建一个新对象
2.将构造函数的作用域赋给新对象（因此this就指向了这个新对象）
3.执行构造函数中的代码（为这个新对象添加属性）
4.返回新对象
优点：创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型
缺点：每个方法都要在每个实例上重新创建一遍，在上面的例子中，person1和person2都有一个名为sayName()的方法，但那两个方法不是同一个Function的实例，创建两个完成同样任务的Function实例的确没有必要；况且有this对象在，根本不用在执行代码前就把函数绑定到特定对象上面。

alert(person1.sayName == person2.sayName)  //flase

因此可以像下面这样，通过把函数定义转移到构造函数外部来解决这个问题。

function Person(name, age, job){     this.name = name;     this.age = age;     this.job = job;     this.sayName = sayName; } function sayName(){     alert(this.name); 
} var person1 = new Person("Nicholas", 29, "Software Engineer"); 
var person2 = new Person("Greg", 27, "Doctor"); 

在这个例子中，我们把 sayName()函数的定义转移到了构造函数外部。而在构造函数内部，我们 将 sayName 属性设置成等于全局的 sayName 函数。这样一来，由于 sayName 包含的是一个指向函数 的指针，因此 person1 和 person2 对象就共享了在全局作用域中定义的同一个 sayName()函数。这 样做确实解决了两个函数做同一件事的问题，可是新问题又来了：在全局作用域中定义的函数实际上只 能被某个对象调用，这让全局作用域有点名不副实。而更让人无法接受的是：如果对象需要定义很多方 法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。好在， 这些问题可以通过使用原型模式来解决。

三、原型模式

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

function Person(){}Person.prototype.name = 'll';Person.prototype.age = '20';Person.prototype.job = 'web';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 

虽然我们可以通过对象实例访问保存在原型中的值，但却不能通过对象实例重写原型中的值，如果我们再实例中添加一个属性，而该属性实例原型中的一个属性名同名，那我们就在实例中创建该属性，该属性将会屏蔽原型中的那个属性。不过可以使用delete删除属性。

function Person(){}Person.prototype.name = 'll';Person.prototype.age = '20';Person.prototype.job = 'web';Person.prototype.sayName = function(){alert(this.name);};var person1 = new Person();
var person2 = new Person();
person1.name  = 'lh';
console.log(person1.name)  //'lh'    来自实例
conosole.log(person2.name)  //'ll'   来自原型delete person1.name;
console.log(person1.name)  //'ll'  来自原型

原型模式也不是没有缺点。首先，它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在某种程度上带来一些不方便，但还不是原型的最大问题。原型模式的最大问题是由共享的本性所导致的。
原型中所有属性是被很多实例共享的，这种共享对于函数非常合适。对于那些包含基本值的属性倒也说的过去，通过在实例上添加一个同名属性，可以隐藏原型中的对应属性。然后，对于包含引用类型的属性来说，问题就比较突出了。

function Person(){ } Person.prototype = {     constructor: Person,     name : "Nicholas",     age : 29,     job : "Software Engineer",     friends : ["Shelby", "Court"],     sayName : function () {         alert(this.name);     } 
}; var person1 = new Person(); 
var person2 = new Person(); person1.friends.push("Van"); alert(person1.friends);    
//"Shelby,Court,Van" 
alert(person2.friends);   
//"Shelby,Court,Van" 
alert(person1.friends === person2.friends);  
//true 

在此，Person.prototype 对象有一个名为 friends 的属性，该属性包含一个字符串数组。然后， 创建了 Person 的两个实例。接着，修改了 person1.friends 引用的数组，向数组中添加了一个字符 串。由于 friends 数组存在于 Person.prototype 而非 person1 中，所以刚刚提到的修改也会通过 person2.friends（与 person1.friends 指向同一个数组）反映出来。假如我们的初衷就是像这样 在所有实例中共享一个数组，那么对这个结果我没有话可说。可是，实例一般都是要有属于自己的全部 属性的。而这个问题正是我们很少看到有人单独使用原型模式的原因所在。

四、组合使用构造函数模式和原型模式

构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本， 但同时又共享着对方法的引用，大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数。（最常用的方式）

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

在这个例子中，实例属性都是在构造函数中定义的，而由所有实例共享的属性 constructor 和方法 sayName()则是在原型中定义的。而修改了 person1.friends（向其中添加一个新字符串），并不 会影响到 person2.friends，因为它们分别引用了不同的数组。

五、动态原型模式

动态原型模式把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型。

function Person(name, age, job){ //属性     this.name = name;     this.age = age;     this.job = job; //方法     if (typeof this.sayName != "function"){              	Person.prototype.sayName = function(){        alert(this.name);         };              } } var friend = new Person("Nicholas", 29, "Software Engineer"); 
friend.sayName();  

注意：构造函数代码中的if语句，这里只在sayName()方法不存在的情况下才会将它添加到原型中。这断代码只有在第一次调用构造函数的时候才会被执行。此后，原型已经被初始化，不需要再做什么修改。不过要记住，这里所做的修改能立即在所有实例中得到反映。因此，这种方法可以说确实非常完美。其中if语句检查的是初始化之后应该存在的任何方法和属性–不必再用一大堆if来检查每个属性和方法，只检查其中一个即可。对于采用这样模式创建的对象，还可以使用instanceof操作符来确定他的类型。
注意：使用动态原型模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有的实例与新原型之间的联系。

六、寄生构造函数模式

这种模式 的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但 从表面上看，这个函数又很像是典型的构造函数。

function Person(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 friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();  //"Nicholas" 

除了使用new操作符把使用的包装函数叫做构造函数之外，这个模式和工厂模式并没有多大的区别。构造函数在不返回值的情况下，会默认返回新对象的实例。而通过在构造函数的末尾添加一个return语句，可以重写调用构造函数时返回的值。
关于寄生构造函数模式，有一点需要说明：首先，返回的对象与构造函数或者与构造函数的原型属性之间没有关系；也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此， 不能依赖 instanceof 操作符来确定对象类型。由于存在上述问题，我们建议在可以使用其他模式的情 况下，不要使用这种模式。

七、稳妥构造函数模式

所谓稳妥对象，是指没有公共属性，而且其方法也不引用this对象。稳妥对象最适合在一些安全环境中（这些环境会禁止使用this和new），或者在防止数据被其他应用程序改动时使用。稳妥构造函数遵循的与寄生构造函数类似的模式，但又两点不同：一是新创建对象的实例方法不引用this；二是不使用new操作符调用构造函数。按照稳妥构造函数的要求，可以将前面的Person构造函数重写如下：

function Person(name, age, job){//创建要返回的新对象var o = new Object();//可以在这里定义私有变量和函数//添加方法o.sayName = function(){alert(this.name);};//返回对象return o;
}

注意：在以这种模式创建的对象中，除了使用sayName()方法之外，没有其他办法访问name的值。可以像下面使用稳妥的Person构造函数：

var person =Person("weiqi",22,"banzhuan");
person.sayName(); //weiqi

这样，变量person中保存的是一个稳妥对象，而除了sayName()方法外，没有别的方式可以访问其他数据成员。即使有其他代码会给这个对象添加方法或数据成员，但也不可能有别的办法访问传入到构造函数中的原始数据。稳妥构造函数模式提供的这种安全性，使得他非常适合在某些安全执行环境–例如，ADsafe(ADsafe)提供的环境下使用。

注意：与寄生构造函数模式类似，使用稳妥构造函数模式创建的对象与构造函数之间没有什么关系，因此instanceof操作符对这种对象也没有意义。

原文链接：https://blog.csdn.net/weixin_41910848/article/details/82286023