## 工厂模式
```JavaScript
function createPerson(name, job) {
var o = new Object()
o.name = name
o.job = job
o.sayName = function () {
console.log(this.name)
}
return o
}
var person1 = createPerson('WangXiaoNao','Student')
var person2 = createPerson('Tom','Teacher')
person1.sayName()
person2.sayName()
```
可以无数次调用这个工厂函数,每次都会返回一个包含两个属性和一个方法的对象
工厂模式虽然解决了创建多个相似对象的问题,但是没有解决对象识别问题,即不能知道一个对象的类型
---
## 构造函数模式
```JavaScript
function Person(name,job) {
this.name = name
this.job = job
this.sayName = function () {
console.log(this.name)
}
}
var person3 = new Person('WangXiaoNao','Student')
var person4 = new Person('Tom','Teacher')
person3.sayName()
person4.sayName()
```
没有显示的创建对象,使用new来调用这个构造函数,使用new后会自动执行如下操作:
* 创建一个新对象
* 这个新对象会被执行[[prototype]]链接
* 这个新对象会绑定到函数调用的this
* 返回这个对象
使用这个方法创建对象可以检测对象类型
console.log(person3 instanceof Object) // true
console.log(person4 instanceof Person) //true
* instanceof运算符用来判断一个构造函数的prototype属性所指向的对象是否存在另外一个要检测对象的原型链上(nstanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上),[详细理解instanceof运算符](https://www.cnblogs.com/SourceKing/p/5766210.html)
但是使用构造函数创建对象,每个方法都要在每个实例上重新创建一次
---
## 原型模式
```JavaScript
function Person() {
}
Person.prototype.name = 'WangXiaoNao'
Person.prototype.job = 'Student'
Person.prototype.sayName = function () {
console.log(this.name)
}
var person5 = new Person()
person5.sayName()
```
将信息直接添加到[原型对象](http://blog.csdn.net/u012468376/article/details/53121081)上。使用原型的好处是可以让所有的实例对象`共享`它所包含的属性和方法,不必在构造函数中定义对象实例信息。
### 更简单的写法
```JavaScript
function Person() {
}
Person.prototype = {
name:'WangXiaoNao',
jon:'Student',
sayName:function () {
console.log(this.name)
}
}
var person = new Person()
person.sayName()
```
将Person.prototype设置为等于一个以`对象字面量`形式创建的对象,但是会导致.constructor不在指向Person了。
使用这种方式,完全重写了默认的Person.prototype对象,因此 .constructor也不会存在这里
console.log(Person.prototype.constructor === Person) //false
如果需要这个属性的话,可以手动添加
```JavaScript
function Person() {
}
Person.prototype = {
constructor:Person,
name:'WangXiaoNao',
jon:'Student',
sayName:function () {
console.log(this.name)
}
}
var person = new Person()
person.sayName()
console.log(Person.prototype.constructor === Person) //true
```
不过这种方式还是不够好,应为constructor属性默认是不可枚举的,这样直接设置,它将是可枚举的。所以可以时候,Object.defineProperty方法
Object.defineProperty(Person.prototype,'constructor',{
enumerable:false,
value:Person
})
* 缺点
使用原型,所有的属性都将被`共享`,这是个很大的优点,同样会带来一些缺点
原型中所有属性实例是被很多实例共享的,这种共享对于函数非常合适。对于那些包含基本值的属性也勉强可以,毕竟实例属性可以屏蔽原型属性。但是引用类型值,就会出现问题了
```JavaScript
function Person() {
}
Person.prototype = {
name:'WangXiaoNao',
friends:['Tom','Teacher']
}
var person = new Person()
var person2 = new Person()
person.friends.push('Van')
console.log(person.friends)
console.log(person2.friends)
console.log(person.friends === person2.friends)
```
![](https://i.imgur.com/I7Mg4To.png)
friends存在与原型中,实例person1和person2指向同一个原型,person1修改了引用的数组,也会反应到实例person2中
## 组合使用构造函数模式和原型模式(推荐使用)
这是使用最为广泛、认同度最高的一种创建自定义类型的方法。它可以解决上面那些模式的缺点
使用此模式可以让每个实例都会有自己的一份实例属性副本,但同时又共享着对方法的引用
这样的话,即使实例属性修改引用类型的值,也不会影响其他实例的属性值了
```JavaScript
function Person(name) {
this.name = name
this.friends = ['Tom','Amry']
}
Person.prototype.sayName = function () {
console.log(this.namedCurve)
}
var person = new Person()
var person2 = new Person()
person.friends.push('Van')
console.log(person.friends)
console.log(person2.friends)
console.log(person.friends === person2.friends)
```
![](https://i.imgur.com/c3AO48D.png)
---
## 动态原型模式(推荐使用)
动态原型模式将所有信息都封装在了构造函数中,初始化的时候,通过检测某个应该存在的方法时候有效,来决定是否需要初始化原型
```JavaScript
function Person(name,job) {
// 属性
this.name = name
this.job = job
// 方法
if(typeof this.sayName !='function'){
Person.prototype.sayName = function () {
console.log(this.name)
}
}
}
var person = new Person('WangXiaoNao','Student')
person.sayName()
```
* typeof的介绍
typeof 运算符把类型信息当作字符串返回。typeof 返回值有六种可能: "number," "string," "boolean," "object," "function," 和 "undefined."我们可以使用typeof来获取一个变量是否存在,如if(typeof a!="undefined"){},而不要去使用if(a)因为如果a不存在(未声明)则会出错,对于Array,Null等特殊对象使用typeof一律返回object,这正是typeof的局限性。
只有在sayName方法不存在的时候,才会将它添加到原型中。这段代码只会初次调用构造函数的时候才会执行。
此后原型已经完成初始化,不需要在做什么修改了
这里对原型所做的修改,能够立即在所有实例中得到反映
其次,if语句检查的可以是初始化之后应该存在的任何属性或方法,所以不必用一大堆的if语句检查每一个属性和方法,只要检查一个就行
---
## 寄生构造函数模式
这种模式的基本思想就是创建一个函数,该函数的作用仅仅是封装创建对象的代码,然后再返回新建的对象
```JavaScript
function Person(name, job) {
var o = new Object()
o.name = name
o.job = job
o.sayName = function () {
console.log(this.name)
}
return o
}
var person = new Person('WangXiaoNao', 'Student')
person.sayName()
```
这个模式,除了使用new操作符并把使用的包装函数叫做构造函数之外,和工厂模式几乎一样
构造函数如果不返回对象,默认也会返回一个新的对象,通过在构造函数的末尾添加一个return语句,可以重写调用构造函数时返回的值
---
## 稳妥构造函数模式
首先明白稳妥对象指的是没有公共属性,而且其方法也不引用this。
稳妥对象最适合在一些安全环境中(这些环境会禁止使用this和new),或防止数据被其他应用程序改动时使用
稳妥构造函数模式和寄生模式类似,有两点不同:一是创建对象的实例方法不引用this,而是不使用new操作符调用构造函数
```JavaScript
function Person(name,job) {
var o = new Object()
o.name = name
o.job = job
o.sayName = function () {
console.log(name)
}
return o
}
var person = Person('WangXiaoNao','Student')
person.sayName()
```
和寄生构造函数模式一样,这样创建出来的对象与构造函数之间没有什么关系,instanceof操作符对他们没有意义
---