创建对象的七种方式

创建对象的第一种方式：工厂模式

用函数来封装以特定接口创建对象的细节

    function createPerson(name,age,job){
        var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
            alert(this.name);
        };
        return o;
    }
    var personal1 = createPerson("罗怡",18,"学生");
    var personal2 = createPerson("白晨兮",19,"学生");
    console.log(personal1.name);
    console.log(personal2.age);

构造函数模式

用构造函数创建指定类型的对象，在运行时会自动出现在执行环境中

创建自定义的构造函数，从而定义自定义对象类型的属性和方法

1.创建一个新对象 2.将构造函数的作用域赋给新对象 3.执行构造函数 4.返回新对象

    function person(name,age,job) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.sayName = function(){
            alert(this.name);
        }
    }
    var personal1 = new person("罗怡",18,"学生");
    var personal2 = new person("白晨兮",19,"学生");
    console.log(personal1.sayName());
    console.log(personal2.job);
    console.log(personal1.constructor == person);
    console.log(personal2.constructor == person);

原型模式

prototype是通过调用构造函数而创建的那个对象实例的原型对象

不必在构造函数中定义对象实例信息，而是将这些信息直接添加到原型对象中

可以让所有对象实例共享它所包含的属性和方法

    function person() {
    }
    person.prototype.name = "罗怡";
    person.prototype.age = 18;
    person.prototype.job = "学生";
    person.prototype.sayName = function () {
        alert(this.name);
    }
    var personal1 = new person();
    var personal2 = new person();
    personal1.sayName();
    personal2.sayName();

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

实例属性在构造函数中定义，而所有实例共享的属性都定义在原型上

使用度最广泛，认同度最高的一种创建对象的方式，可以说这是用来定义引用类型的默认方式

    function person(name,age,job){
        this.name = name;
        this.age = age;
        this.job = job;
        this.friend = ["lay","out"];
    }
    person.prototype = {
        constructor : person,
        sayName : function(){
            alert(this.name);
        }
    };
    var personal1 = new person("罗怡",18,"学生");
    var personal2 = new person("陈浩",20,"不知道");
    console.log(personal1.age);
    console.log(personal2.job);

    personal1.friend.push("douKou");
    console.log(personal1.friend);
    console.log(personal2.friend);
    console.log(personal1.sayName === personal2.sayName);

动态原型模式

把所有信息都封装在构造函数中，而通过在构造函数中初始化原型，又保持了同时使用构造函数和原型的优点

即通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型

    function person(name,age,job){
        this.name = name;
        this.age = age;
        this.job = job;
        if(typeof this.sayName != 'function'){
            person.prototype.sayName = function(){
                console.log(this.name);
            }
        }
    }

    var personal = new person("罗怡",18,"学生");
    personal.sayName();

寄生构造函数模式

创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象

返回的对象与构造函数或者与构造函数的原型属性之间没有什么关系，

所以不能依赖instanceof操作符来确定对象类型

    function specialArray(){
//        创建数组
        var value = new Array();
//        添加值
        value.push.apply(value,arguments);
//        添加方法
        value.toPipeString = function(){
            return this.join("|");
        };
        return value;
    }
    var color = new specialArray("red","yellow","green");
    console.log(color.toPipeString());

稳妥构造函数模式

稳妥对象：没有公共属性，其方法也不引用this对象

稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同

一是新创建对象的实例方法不引用this，二是不使用new操作符调用构造函数

// 安全性较好，比较适合某些安全执行环境

    function person(name,age,job){
        var o = new Object();
            var nameL = name;
            var ageL = age;
            var jobL = job;
        o.sayName = function(){
            console.log(nameL);
        };
        return o;
    }
    var personal = person("罗怡",18,"学生");
    personal.sayName();
    console.log(personal.nameL);