前面的两篇文章中，我们分别提到了工厂模式、构造函数模式和原型模式创建对象，这三种模式是最基础的创建对象的模式，接下来介绍的几种模式，都是在这些模式基础上演变而来的。首先是构造函数模式和原型模式的结合使用。
构造函数模式和原型模式的结合使用
首先回顾下这两种模式各自的优缺点，构造函数模式：
- 优点：对象的属性各自独立，没有引用关系
- 缺点：造成内存浪费，不能很好的复用代码
原型模式：
- 有点：可以有效的复用和共享代码
- 缺点：如果共享的是引用类型数据，有一些陷阱
如果我们将二者进行结合使用：构造函数中个用来初始化对象特有的属性，包括引用类型的数据，原型负责整合公共的、可复用的代码，那么就是一个比较完美的创建对象的模式了。
// 定义类
function Person(name,age,hobby){
this.name = name
this.age = age
this.hobby = hobby
}
// 定义原型
Person.prototype.sayName = ...
Person.prototype.sayAge = ...
Person.prototype.sayHobby = ...
这种将构造函数模式和原型模式结合的形式，是使用最为广泛的方式了。
动态原型模式
上面介绍的构造函数模式和原型模式结合的方法，在一定程度上分离了构造函数和原型，看起来二者是分开进行设置的。为了解决这个问题，出现了动态原型模式 —— 将原型声明和构造函数放在一起。
function Person(name,age,hobby){
this.name = name
this.age = age
this.hobby = hobby
if(typeof this.sayName !== "function"){
Person.prototype.sayName = ...
Person.prototype.sayAge = ...
Person.prototype.sayHobby = ...
}
}
上面将原型和属性定义都发放在了构造函数中，目的是为了让原型和构造函数看起来更为统一。在第一次初始化（创建对象）时，会检查该对象上有没有某个方法或者属性，这些待检查的方法或者属性是原型链上的属性，如果没有这些属性，那么就在构造函数的 prototype 上进行相应的声明。
这个赋值只会进行一次，当创建另一个对象时，检查到构造函数的 prototype 上有相应的属性，就不会重复创建了。
由于构造函数的 prototype 不是一开始声明的，而是在第一次创建对象时动态构造的，所以这个方法也就叫做动态原型模式。
另外，由于我们是根据构造函数的 prototype 上是否有相应的属性和方法来决定是否初始化 prototype 属性，这个判断只需要进行一次就够了，无需对每个属性和方法都进行一次判断，只需要在一次判断后进行整体设置即可。
就我个人而言，可能更喜欢这样的方式，使用闭包的写法：
const Person = (function(){
function setProperty(){
if(typeof this.sayName !== "function"){
Person.prototype.sayName = ...
Person.prototype.sayAge = ...
Person.prototype.sayHobby = ...
}
}
return function(name,age,hobby){
this.name = name
this.age = age
this.hobby = hobby
// 检查原型
setProperty.call(this)
}
}())
上面的方式代码量看起来要多一些，也使用了闭包，可能要更加难以理解一些，但是对于构建共享方法较多的大型对象来说，逻辑上可能更清楚一些。
寄生构造函数模式
在说寄生构造函数之前，需要再说一下关于构造函数第一个问题：我们构造函数是通过 new 操作符调用，然后返回一个基于构造函数的 prototype 作为原型的对象。这是默认的情况，我们也可以手动返回一个对象，作为新创建的对象。
function Test(){
let arr = [1,2,3]
return arr
}
let t = new Test()
t //[1,2,3]
是不是很神奇很美妙呢？寄生构造函数就是基于这个原理。
function Person(name,age){
let o = new Object()
o.name = name
o.age = age
return o
}
可见，寄生构造函数模式和工厂模式基本上是一毛一样的，区别只在于寄生构造函数模式既可以使用 new 操作符调用创建对象，又可以直接调用构造函数创建对象，而工厂模式只能通过直接调用工厂函数创建对象。
二者的缺陷都在于：无法对创建的对象实例的类型（父类）进行判断。
寄生构造函数模式的用途
寄生构造函数模式有一个典型的用途：当我们需要改造某一个原生（或者其他定义好的）类型的行为，但又不想直接在原生（或者其他定义好的）类型的原型，就可以使用这种方式。
function MyArray(){
let arr = []
arr.push(...arguments)
arr.sayHello = function(){
console.log("Hello")
}
return arr
}
可见，调用 MyArray 函数创建的对象完全继承了 Array 的 prototype 上的方法，还增加了自己的一些实现，并且没有修改原生的 Array 的 prototype，这就好像寄生在 Array 内部一样，因此得名。
稳妥构造函数模式
稳妥对象是一个概念：没有公共属性，该对象的方法中不通过 this 引用对象，该对象的构造也不通过 new 完成。
这种对象适用于一些安全的、禁止使用 this 和 new 的环境中（我也不知道这个“完全环境”指的是哪一类环境，知道的麻烦说下~）。
// 定义安全构造对象的函数
function Person(name,age){
let o = new Object()
o.sayName = function(){
console.log(name)
}
o.sayAge = function(){
console.log(age)
}
return o
}
// 创建安全对象
let person = Person("MIKE","20")
person.sayName() //"MIKE"
person.sayAge() //"20"
上面定义的 Person 函数在调用时，会返回一个对象，该对象通过闭包访问 Person 函数的两个参数 name 和 age，这两个“属性”没有直接挂载到对象上，而是让对象的两个方法 sayName 和 sayAge 可以通过闭包分别访问这两个属性。该对象就是一个稳妥对象，可以在禁止使用 this 的环境中使用，同时，该对象也可以不通过 new 操作符构造。
Person 函数在运行完成后，本应该释放其内部的作用域，但是由于起作用域中的变量（name 和 age）被其他函数引用了，因此 Person 函数的作用域不会被释放。整个创建对象的过程是基于闭包的原理，跟 Person 对象的 prototype 属性没有任何关系，因此通过这种方式创建的对象和通过工厂模式、寄生构造函数模式创建出的对象一样，都无法通过 instanceof 操作符对其所属的类型（父类）进行判断。
总结
本文我们介绍了创建对象的另外几种方式，至目前为止，我们已经介绍了这么几种方法：
- 工厂模式
- 构造函数模式
- 原型模式
- 构造函数模式和原型模式结合
- 动态原型模式
- 寄生构造函数模式
- 稳妥构造函数模式
这些模式各有特点，适合在不同的场景下使用，但由于这些模式的名称有点纷繁，全部记住是有难度的~
在有需要的时候，请记得几篇文章，不时回头来看看，就好啦。
完。
