创建对象

创建对象的方式有以下几种：最简单的就是对象字面量形式。

工厂模式

说起工厂模式这个称呼的由来，可以根据它的书写方式来理解：

function factory(name, speed) {
  var obj = new Object()
  obj.name = name
  obj.speed = speed
  return obj
}
var car1 = factory('保时捷', 300)
var car2 = factory('保时捷', 280)
car1.constructor  // function Object() {}
car2.constructor  // function Object() {}

如上代码所示，你可以把factory()当成一个生产保时捷的工厂，你可以给他传入一些零件（即参数），工厂内部就可以根据你传入的零件，在一个车架的基础上（即 new Object()），建造一辆汽车。当你提起这个工厂，自然而然就跟保时捷划等号了。
不过，有可能好几个工厂同时生产同一版本的车，单从外表你是不知道它到底是哪个工厂生产出来的，只知道都长的差不多。

模式存在的问题

这也就是工厂模式的问题，不能确定对象属于哪一类。

构造函数模式

都知道，可以用构造函数来创建对象。可以用原生构造函数也可以用自定义的构造函数。相对于工厂模式来创建对象的方式，构造函数不会显示的创建一个对象，而且不会直接在对象上添加属性和方法，而是通过this对象，最后，并没有return语句。

function Person(name, age, sex) {
  this.name = name
  this.age = age
  this.sex = sex
  this.say = function() {
    console.log(this.name)
  }
}
var person1 = new Person('zhd', 18, 'boy')
var person2 = new Person('zy', 20, 'girl')

如上所示，，通过Person()这个构造函数生成了person1和person2两个对象，也就是两个构造函数的实例，这两个实例的属性和方法都来自于 Person()构造函数。不过，重点是new操作符。
首先来看一下new操作符都干了些啥？

new操作符干了啥

1）最直接的就是通过new操作符创建了一个新对象
2）将构造函数内部this的作用域指向了创建的这个新的对象
3）将构造函数内部的属性和方法添加到新对象中
4）返回这个新对象，并将这个对象当做值赋给变量person1和person2

回到工厂模式存在的问题，构造函数创建的对象是否就知道是哪里一类吗？试验一下：

person1.constructor  // function Person() {}
person2.constructor  // function Person() {}

从上面代码来看，确实解决了工厂模式创建对象的问题。不过也可以用另一种方式实验：

person1 instanceof Person // true
person1 instanceof Object // true
person2 instanceof Person // true
person2 instanceof Object // true

如果把构造函数当做正常的一个函数来调用呢，那内部的属性和方法都跑哪里去了？实际上，如果不通过new调用构造函数的话，直接运行构造函数，会把构造函数内部的属性和方法放在window上。

工厂模式创建的对象不知道属于哪种类型，那构造函数有什么问题呢？
通过new确实会创建一个对象，不过没创建一个对象，都会把构造函数内部所有的方法都添加到新对象上，这样，如果基于这个构造函数创建很多对象，每个方法都会在实例内部创建一遍，但是每个实例内部的方法干的都是同一件事，不仅造成了多余方法的冗余，也无形增加了内存消耗。

模式存在的问题

每个方法都要在实例上重新创建一遍

那有什么解决的办法呢？实际上，创建的对象内部的方法，对于实例来说干的都是同一件事，那为什么不写成公用的一个方法呢？如下：

function Person(name, age, sex) {
  this.name = name
  this.age = age
  this.sex = sex
  this.say = say
}
function say () {
  console.log(this.name)
}

但是这种解决方案带来了一个无法让人接受的问题：那就是在做封装的时候，通常会定义很多方法，如果这个对象需要定义很多方法，也就是定义很多全局变量，这样既没有封装性可言，而且增加了全局变量。

原型模式

上面提到的构造函数的问题，可以通过第三种模式，原型模式解决它。

function Person() {
 
}
Person.prototype.name = 'zhd'
Person.prototype.age = 18
Person.prototype.sex = 'boy'
Person.prototype.say = function() {
  console.log(this.name)
}
var person1 = new Person()
var person2 = new Person()
person1.say() // 'zhd'
person2.say() // 'zy'

通过以上的方式就可以看出，将所有实例共用的方法添加到构造函数的原型上，这样既减少了定义函数的次数，又没有增加全局变量。

理解原型

这里只简单说几点
1）除了函数，其他所有对象都没有prototype属性。
2）所有对象都有一个_proto_属性，指向构造函数的原型。
3）除了null和undefined，其他所有对象都有constructor属性。

相关的方法

isPrototypeOf()：通过这个方法可以确定一个对象是否是另一个对象的原型。
例如：
Object.prototype.isPrototypeOf(person1)
// true

hasOwnProperty()：通过这个方法可以检测一个属性是否存在于实例中还是原型中。这个方法接收一个属性名作为参数，由所要查找属性所在的对象调用。
例如：
person1.__proto__.hasOwnProperty('name')
// true
person1.hasOwnProperty('name')
// false

Object.getPrototypeOf()：通过这个方法可以返回一个对象的原型对象。
例如：
Object.getPrototypeOf(person1)
// {name:'zhd', age:18, sex:'boy', say:function(){...}}

Object.keys()：这个方法返回的一个对象上所有可枚举实例属性，这个方法接收一个对象作为参数，返回一个包含所有属性的字符串数组。
例如：
Object.keys(Person.prototype)
// ["name", "age", "sex", "say"]

Object.getOwnPropertyNames()：上面说的Object.keys()方法返回的是所有可枚举的实例属性，相反，这个方法更全面。返回的是所有属性，不管属性是否可枚举
例如：
Object.getOwnPropertyNames(Person.prototype)
// ["constructor", "name", "age", "sex", "say"]

这里有一点需要提醒的是，如果实例和原型存在相同的一个属性或者方法，实例的属性或方法会覆盖原型上的属性或方法。

更简单的原型语法

上面提到的原型模式，如果每添加一个属性或方法，就要写一遍Person.prototype,为了更优雅的封装功能，我们可以改变Person的prototype。
例如：

function Person() {}
Person.prototype = {
  name: 'zhd',
  age: 18,
  sex: 'boy',
  say: function() {
    console.log(this.name)
  }
}

这样的写法是不是就轻松多了。不过这样方式修改了Person的原型对象，能带来什么问题吗？如下：

var person1 = new Person()
person1.constructor == Person // false

为什么会是false呢？
之前介绍过，一旦创建一个函数，就会同时创建它的prototype对象，这个对象也会自动获得一个constructor属性。就像上面一样，一旦声明一个Person构造函数，就同时创建了一个它的原型对象（{constructor:function() {}}）,同时这个原型对象也会获得一个constructor属性。
所以这种写法，声明一个构造函数以后，又修改了它的原型对象，因此，修改后的原型对象内部的constructor也不再指向Person了，而是指向了原生构造函数function Object() {}。
为了解决这种写法带来的问题，我们可以在改变构造函数的原型对象后，手动的在原型对象中添加一个constructor属性，其属性值为Person。如下：

Person.prototype = {
  constuctor: Person,
  name: 'zhd',
  age: 18,
  sex: 'boy',
  say: function() {
    console.log(this.name)
  }
}

我们这样手动添加constructor属性确实解决了写法带来的问题。不过constructor这个属性本身是不可枚举的，我们可以用Object.defineProperty()方法来改变它的特性。如下：

Object.definePropety(Person.prototype, 'constructor', {
  enumerable: false,
  value: Person
})

in 操作符的使用

有两种方式使用in操作符：
1）单独使用，如propertyName in object

2. 在 for-in循环中使用

不过单独使用in操作符，有一个缺点，如下：

function Person () {}
Person.prototype.name = 'zhd'
console.log('name' in Person) // true

所以，当单独用in操作符检测一个属性是否在目标对象上，结果并不准确，如果属性在目标对象的原型上，也会返回true。
所以，搭配hasOwnProperty()方法一起使用，就可以确定要检测的属性是否在对象上还是在原型上。

模式存在的问题

首先，从原型模式的写法上可以看出，省略了构造函数的传参和初始化这一环节，结果是所有实例会默认取得相同的属性和方法，增加了冗余。
但是，原型模式最大的问题是在共享的本质。尤其是对于包含引用类型值得属性。
如下：

function Person () {}
Person.prototype = {
  constructor: Person,
  name: ['person1', 'person2']
}
let person1 = new Person()
let person2 = new Person()
person1.name.push('person3')
console.log(person2.name) // ['person1', 'person2', 'person3']

开发者的意思只是修改一下person1这个实例的name属性，无意修改person2这个实例的name属性。如果说这两个实例共享的是一个name，那就没问题，如果是每个实例独享一个name属性，并做相应的业务逻辑处理，那岂不是翻天了。为了避免这方面的问题，建议构造函数模式和原型模式组合使用。

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

function Person(name, age, sex,fn) {
  this.name = name
  this.age = age
  this.sex = sex
  this.fn = fn
}
Person.prototype.sayName = function() {
  console.log(this.name)
}
let person1 = new Person('zhd','18','boy')

这种组合模式的使用，既照顾到了每个实例私有的属性和方法,又把实例共享的方法或属性放在了原型上面，一举两得。在这先提一下：也推荐借用构造函数和原型链组合的继承方式。这一点会在后面说出。

动态原型模式

其实，动态原型模式很简单，基本上相当于构造函数模式和原型模式的组合使用，区别就是加了一个if判断，而且把原型模式写在了构造函数内部。如下：

function Person(name) {
  this.name = name
  if(typeof this.sayName != 'function') {
    Person.prototype.sayName = function() {
      console.log(this.name)
    }
  }
}

之前提到了构造函数模式和原型模式的组合模式的使用，而动态原型模式其实也是一样，只是判断了一下构造函数内部有没有对象的方法，没有的话直接把方法放到原型上。

其实，讲到这里，项目中常用的方法就已经说的差不多了。创建对象无非就是以上的几种方法。不过还有两种，不常用，但咱们一起来了解一下。

寄生构造函数模式（工厂构造模式）

其实，刚开始看到这一个模式的写法的时候，我感觉与其叫寄生构造函数模式，不如叫工厂构造模式更好理解，为啥这么说呢，我们来看一看它的写法：

function Person(name, age, sex) {
  var o = new Object()
  o.name = name
  o.age = age
  o.sex = sex
  o.joins = function() {
    this.name = '111'
  }
  return o
}
let person1 = new Person('zhd','19','boy')

对工厂模式和构造函数模式特别熟悉的同学一看就知道，这不就是工厂模式和构造函数模式组合使用吗。或者说，在工厂模式的基础上，生成对象的时候，在构造函数前面加了一个new操作符，仅此而已。
然后，我啥也不说，咱们先看一段代码

let person1 = new Person('zhd','19','boy')
let person2 = Person('zhd','19','boy')
console.log(person1) // {name: 'zhd', age:19,sex:'boy',joins:function(){}}
console.log(person2) // {name: 'zhd', age:19,sex:'boy',joins:function(){}}

从上面可以看出，无论是从寄生构造函数模式创建的对象，还是从工厂模式常见的对象，从数据结构上来说，没有什么不同。也就是说，构造函数内部返回的对象与构造函数本身是没有关系的，无论是否用new操作符，创建的对象都是一样的，跟构不构造没关系。所以在此，用 instanceof来确定一个对象从哪个对象来的是不正确的。
如：person1 instanceof Person: // false

稳妥构造函数模式

从这个模式的名称来看，也是依托于构造函数来创建对象的。具体的方式来看下面的代码：

function Person(name, age, sex) {
  let o = new Object()
  o.sayName = function() {
    console.log(name)
  }
  return o
}
let person1 = Person('zhd', '18', 'boy')

从官方定义来看，所谓的稳妥，是指通过参数形式传入到模式内部的实参，没有方法和属性能访问到，除了模式内部存在的方法和属性，你不能人为的添加属性和方法取访问它。他没有公共的属性，而且内部也不会通过this这个对象去访问参数。
从书写方式上来看，同寄生构造函数模式有两点不同：一是不通过this访问数据成员，二是不使用new操作符调用构造函数来创建对象。