JavaScript 中创建对象的方式有很多，比如对象字面量模式或者使用 Object 创建：
// 创建 obj1 对象
let obj1 = {
name:"",
showName(){ return this.name }
}
// 创建 obj2 对象
let obj2 = new Object()
obj2.name = ""
obj2.showName = function(){ return this.name }
使用这两种方式（特别是对象字面量方式）创建对象十分方便，可以拿来即用。但也有一些缺点：
- 过程过于繁琐，如果需要创建多个对象，就需要书写多次创建代码
- 封装性不够，因为按照常规理念， 对象应该由一个公共的接口（类、函数）来进行统一创建，需要创建对象时，直接初始化某个类或者调用函数来进行创建。
上面的两个缺陷都指向了一点：我们需要一个函数（类）来进行对象创建，基于这个理念，出现了使用工厂模式来创建对象的方式。
工厂模式
工厂模式很简单，对原料（原生 Object 对象）进行一些加工（参数），然后返回一个产品（被加工后的对象）。
function createPerson(name,age){
// 创建一个原生对象
let o = new Object()
o.name = name;
o.age = age
return o;
}
如果我们需要创建某个对象，只需调用相应的工厂函数：
let p1 = createPerson("MIKE",20)
let p2 = createPerson("JACK",22)
工厂模式的缺点
工厂模式的解决了批量创建对象的问题，但也有一个明显的缺点：没有“类”的概念，除了能够批量创建对象，无法对这些对象进行判断，无法知道这些对象是由谁（类）创建出来的。基于这个问题，出现了构造函数模式。
构造函数模式
函数是 JavaScript 中的一等公民，可以做很多事情，其中有一项功能就是可以被 new 操作符调用。在 ES6 之前，JavaScript 中是没有 class 关键字的，于是有了通过 new 操作符来调用函数创建一个对象的方式，很明显，通过 new 操作符调用的函数就是所谓的“类”。
function Person(name,age){
this.name = name;
this.age = age;
this.intro = function(){
console.log(`name:${this.name},age:${this.age}`)
}
}
接下来通过 Person 类来创建对象：
let p1 = new Person("MIKE",20)
let p2 = new Person("JACK","22")
构造函数中的 this 关键字就指向了当前被创建的对象。
通过这种方式创建对象以后，我们就可以知道对象是被哪个“类”创建的了。
p1 instanceof Person //true
p1 instanceof Object //true
p1.constructor === Person //true
当对象被创建后，其会拥有一个 constructor 属性，指向其的构造函数。不过由于 JavaScript 太灵活了，constructor 属性是可以被修改的，因此通过 constructor 来对对象的类进行判断是不准确的，使用
instanceof 操作符更加可靠。
p1.constructor = Array
p1.constructor // Array
p1.constructor === Person //false
p1 instanceof Person // true
构造函数创建对象的流程
使用构造函数创建对象，大概有如下几个流程：
- 创建一个新对象
- 将构造函数的作用域赋值给这个对象（因此
this就指向了这个对象） - 执行构造函数中的代码，为对象添加属性方法
- 函数执行完毕，对象被销毁
构造函数作为函数
构造函数本身也是函数，因此其可以作为函数调用，由于构造函数中使用 this 关键字，我们可以通过构造函数为某个对象进行赋值。this 为哪个对象赋值，决定于这个函数执行时的上下文。
function Person(name,age){
this.name = name;
this.age = age;
this.intro = function(){
console.log(`name:${this.name},age:${this.age}`)
}
}
let p1 = Person("MIKE","20")
p1 //undefined
window.name //"MIKE"
window.age //"20"
如果不指定函数的上下文，默认为 window 对象，因此 Person 函数执行时，为 window 对象添加了属性和方法。
let o = {}
Person.call(o,"JACK","22")
o //{name:"JACK",age:"22"}
这里明确指定函数的上下文为对象 o 后，调用 Person 函数就为 o 对象添加属性方法了。
构造函数模式的问题
使用构造函数模式创建对象看起来是个不错的方式，但这样有没有缺陷呢？也是有的。这个缺陷就在于每次使用构造函数创建对象时，都会为每个对象重新创建一份属性和方法的副本，无法实现复用。
为什么会这样呢？因为构造函数本质也是一个函数，函数在运行时会有一个独立的作用域，创建多个对象时会多次调用构造函数，并把这些函数的作用域赋值给对象，然后为对象添加属性。但是这些函数的作用域是独立的，因此我们在构造函数体内所做的任何变量声明、函数声明，都会在运行时重新创建一次，然后添加到对象上。
function Person(name,age){
this.name = name;
this.age = age;
this.intro = function(){
console.log(`name:${this.name},age:${this.age}`)
}
}
let p1 = new Person("MIKE","20")
let p2 = new Person("JACK","22")
p1.intro === p2.intro // false
以上就是使用构造函数创建对象无法实现复用的原因，既然无法复用的原因是由于在独立作用于中创建变量和函数，那我们把这些变量和函数放到函数的独立作用于之外不就可以了？确实如此。
function Person(name,age){
this.name = name
this.age = age
this.intro = intro
}
function intro(){
console.log(`name:${this.name},age:${this.age}`)
}
let p1 = new Person("MIKE","20")
let p2 = new Person("JACK","22")
p1.intro === p2.intro // true
上面的 intro 方法就实现了代码复用，节约了资源。但这种方式也是有问题的：增加了全局变量，而且破坏了封装性。后面将会介绍更多创建对象的方法，一步步进行完善。
完。