创建对象的方法有哪些？

1、工厂模式创建对象

    //外部创建
        // function Car(model,color){
        //  this.model = model;
        //  this.color = color;
        // }
        function factory(model,color){
            //内部创建
            function Car(model,color){
                this.model = model;
                this.color = color;
            }
            var o = new Car(model,color);
            return o;
        }

使用工厂模式能够创建一个包含所有信息的对象，可以无数次的调用的这个函数。虽然其解决了创建多个相似对象的问题，但却没有解决对象识别的问题(即如何得知一个对象的类型)

2、构造函数创建对象

    function Car(model,color){
            this.model = model;
            this.color = color;
            this.run = function(){
                console.log(this.model + "跑~");
            }
        }
        var c1 = new Car("x1","blue");
        var c2 = new Car("x2","red");
        c1.run();
        c2.run();
    console.log("构造函数"+c1.run == c2.run);
    //false表示两个不同的函数对象

• 构造函数创建对象缺点：
  函数是对象，c1,c2是不同的两个对象，每次new都会创建一个对象，并且每个方法都有在每个实例上重新创建一遍，占内存占空间

• 解决方法：原型方式创建对象

注意：构造函数其实和普通的函数没有太大的差别，唯一的不同在于调用方式的不同。

3、原型创建对象

        function Apple(name){
            this.name = name;
        }
        Apple.prototype.eat = function(){
            console.log(this.name + "被吃了");
        }
        var a1 = new Apple("红苹果");
        var a2 = new Apple("青苹果");
        a1.eat();
        a2.eat();
        console.log("原型："+a1.eat == a2.eat);
        //true两个对象指向同一个内存区域，省内存

原型模式也不是没有缺点，首先，它省略了构造函数传递初始化参数这一环节，结果所有实例在默认情况下都取得了相同的属性值，这样非常不方便，但这还是不是原型的最大问题，原型模式的最大问题在于共享的本性所导致的，由于共享，因此因此一个实例修改了引用，另一个也随之更改了引用。因此我们通常不单独使用原型，而是结合原型模式与构造函数模式。

4、工厂模式+字面量创建对象

    //var obj = {} 等同于 var obj1 = new Object();
    function ObjectFactory(m,s){
        var o = new Object();
        o.model = m;
        o.size = s;
        return o;
    }
    var c1 = ObjectFactory("t420",14);
    var c2 = ObjectFactory("M920",15);
    var c3 = ObjectFactory("G520",10);
    var c4 = ObjectFactory("K496",13);
    console.log(c1 == c2);//false

5、混合模式（原型模式 + 构造函数模式）

function Blog(name, url, friend) {
  this.name = name;
  this.url = url;
  this.friend = friend;
}
Blog.prototype.alertInfo = function() {
  alert(this.name + this.url + this.friend);
}
var blog = new Blog('wuyuchang', 'http://tools.jb51.net/', ['fr1', 'fr2', 'fr3']);
var blog2 = new Blog('wyc', 'http://**.com', ['a', 'b']);
blog.friend.pop();
blog.alertInfo();  
// wuyuchanghttp://tools.jb51.net/fr1,fr2
blog2.alertInfo(); 
// wychttp://**.coma,b

混合模式中构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性。每个实例都会有自己的一份实例属性，但同时又共享着方法，最大限度的节省了内存。另外这种模式还支持传递初始参数。优点甚多。这种模式在ECMAScript中是使用最广泛、认同度最高的一种创建自定义对象的方法。

6、动态原型模式

function Blog(name, url) {
  this.name = name;
  this.url = url;
  if (typeof this.alertInfo != 'function') {
    // 这段代码只执行了一次
    alert('exe time');
    Blog.prototype.alertInfo = function() {
      alert(thia.name + this.url);
    }
  }
}
var blog = new Blog('wuyuchang', 'http://tools.jb51.net');
var blog2 = new Blog('wyc', 'http:***.com');

动态原型模式将所有信息封装在了构造函数中，而通过构造函数中初始化原型（仅第一个对象实例化时初始化原型），这个可以通过判断该方法是否有效而选择是否需要初始化原型。可以看到上面的例子中只弹出一次窗，'exe time'，即当blog初始化时，这样做blog2就不在需要初始化原型，对于使用这种模式创建对象，可以算是perfect了。