js中创建对象的几种方式及其优缺点

1.通过字面量方式

var obj = {
   'name':'tom',
    sayName:function(){
        cosnole.log(this.name)
    }

}

2.通过new Object() 的方式

var obj = new Object()
obj.name = 'tom'
obj.sayName = function(){
    console.log(this.name)
}

通过以上两种方式创建对象时，会产生大量的代码，所以工厂模式被提出

3.工厂模式

 工厂模式被提出，避免使用过多的代码，来创造相同类型的对象。比如

function person(name,age){
    var o = new Object()
    o.name = name
    o.age = age
    o.sayName = function(){
        cosnole.log(this.name)
    }
    
    return o
}
var person1 = person('tom',18)
var person2 = person('lily',16)

这样当创造相同类型的对象时,避免长生大量代码

当然，这么做的缺点是不能识别这个对象的类型

4.构造函数模式

构造函数模式除了有工厂模式的优势外，它最重要的一点是可以通过instanceof来识别这个对象的类型

function Person(name,age){
    this.name = name
    this.age = age
    this.sayName = function(){
        cosnole.log(this.name)
    }
}
var person1 = new Person('tom',18)
var person2 = new Person('lily',16)
console.log(person1 instanceof Person) // true

构造函数的方式的优点是可以识别它的类型，缺点是每次new它的方法都会被创建一次

5.原型模式

function Person(name,age){
    
}

Person.prototype.name = 'tom'
Person.prototype.age = 18
Person.prototype.sayName = function(){
    console.log(this.name)
}
var person1 = new Person()
person1.sayName() // tom

var person2 = new Person()
person2.sayName() // tom

// 以上方式的封装写法

Person.prototype = {
    name: 'tom',
    age:18,
    sayName:function(){
        console.log(this.name)
    }
    
} 

// 此时相当于重写了原型，同时丢失了原型上的constructor属性,所以更优化的写法如下

Person.prototype = {
    constructor:Person,
    name: 'tom',
    age:18,
    sayName:function(){
        console.log(this.name)
    }
    
} 

原型模式解决了构造函数模式，每次创建对象时都会创建对应的方法的弊端

但是，它也出现一个问题，就是不能传参

为了解决这个问题，我们提出了组合模式

6.组合模式

组合 模式即属性在构造函数内创建(解决无法传参的问题)，方法在原型上创建(解决每次都创建方法的问题)

function Person(name,age){
    this.name = name
    this.age = age
}
Person.prototype.sayName = function(){
    console.log(this.name)
}
var person1 = new Person('tom',18)
person1.sayName() // tom

var person2 = new Person('lily',16)
person2.sayName() // lily