创建对象的多种方式以及优缺点

原文出处

JavaScript深入之创建对象的多种方式以及优缺点
JavaScript高级程序设计（第3版）

---

1.工厂模式

        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 person1 = createPerson("Nicholas", 29, "Software Engineer");
        var person2 = createPerson("Greg", 27, "Doctor");

        console.log(person1.__proto__ === Object.prototype);  // true
        console.log(person2.__proto__ === Object.prototype);  // true

缺点：对象无法识别，因为所有的实例的类型都是Object

2.构建函数模式

        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = function () {
                alert(this.name);
            }
        }

        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        console.log(person1 instanceof Person);  // true
        console.log(person2 instanceof Person);  // true
        console.log(person1.sayName === person2.sayName);  // false

优点：实例可以识别为一个特定的类型
缺点：每次创建实例时，每个方法都要被创建一次

2.1 构造函数优化

        function Person(name) {
            this.name = name;
            this.getName = getName;
        }

        function getName() {
            console.log(this.name);
        }

        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        console.log(person1.sayName === person2.sayName); // true

优点：解决了每个方法都要被重新创建的问题
缺点：封装不好

3.原型模式

        function Person(name, age, job) {}
        Person.prototype.name = "Nicholas";
        Person.prototype.age = 29;
        Person.prototype.job = "Software Engineer";
        Person.prototype.sayName = function() {
            alert(this.name);
        };
        var person1 = new Person();
        person1.sayName(); //"Nicholas"
        var person2 = new Person();
        person2.sayName(); //"Nicholas"
        console.log(person1.sayName == person2.sayName);  //true

优点: 方法不会重新创建
缺点: 1. 所有的属性和方法都共享 2. 不能初始化参数

3.1 原型模式优化

        function Person() {}

        Person.prototype = {
            name: "Nicholas",
            age: 29,
            job: "Software Engineer",
            sayName: function () {
                alert(this.name);
            }
        };

        var person1 = new Person();
        console.log(person1.__proto__.constructor === Object);  //true
        

优点：封装好一点
缺点：之前的所有缺点都还存在，并且构建函数的原型对象的constructor属性已经丢失

3.2 原型模式优化

        function Person() {}
        var friend = new Person();
        Person.prototype = {
            constructor: Person,
            name: "Nicholas",
            age: 29,
            sayName: function () {
                alert(this.name);
            }
        };
        console.log(Person.prototype.constructor === Person); //true
        console.log(friend.__proto__.constructor === Person); //true

优点: 在上一次优化的基础上修复了constructor属性丢失的问题
缺点: 之前的所有缺点都还存在

4组合模式

        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            this.friends = ["Shelby", "Court"];
        }
        Person.prototype = {
            constructor: Person,
            sayName: function () {
                alert(this.name);
            }
        };

        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        console.log(person1.friends === person2.friends);  //false
        console.log(person1.sayName === person2.sayName);  //true

优点: 可以初始化参数，且该共享的共享，该私有的私有，是使用最广泛的方式
缺点：有的人就是希望全部都写在一起，即更好的封装性

4.1 动态原型模式

        function Person(name, age, job) {
            //属性
            this.name = name;
            this.age = age;
            this.job = job;
            this.friends = [1, 2, 3]
            //方法
            if (typeof this.sayName != "function") {
                Person.prototype.sayName = function () {
                    alert(this.name);
                }
            };
        }
        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        console.log(person1.sayName === person2.sayName);  //true
        console.log(person1.friends === person2.friends); //false

优点: 拥有上面的所有优点，且封装比上面好
注意：使用动态原型模式时，不能用对象字面量重写原型
看下面代码：

function Person(name) {
    if (typeof this.getName != "function") {
        Person.prototype = {
            constructor: Person,
            name:  "Nicholas",
            age:  29,
            job:  "Software Engineer",
            sayName: function () {
                console.log(this.name);
            }
        }
    }
}

var friend = new Person('kevin');

// 报错 并没有该方法
friend.sayName();

在这个例子中，我们先创建了Person的一个实例，然后又重写了其原型对象，然后在调用friend.sayName()时发生了错误，因为friend指向的原型中不包含以该名字命名的属性。，过程如下图所示:

5.寄生构造函数模式

        function Person(name, age, job) {
            var o = new Object();
            o.age = age;
            o.name = name;
            o.job = job;
            o.sayName = function () {
                alert(this.name);
            };
            return o;
        }

        var friend = new Person("Nicholas", 29, "Software Engineer");
        console.log(friend instanceof Person);  //false
        console.log(friend.__proto__ === Object.prototype);  //true

缺点: 无法确定对象类型，建议在可以使用其他模式的情况下，不要使用这种模式
优点: 这样方法可以在特殊情况下使用。比如我们想创建一个具有额外方法的特殊数组，但是又不想直接修改Array构造函数，如下

        function SpecialArray() {
            //创建数组 
            var values = new Array();
            //添加值 
            values.push.apply(values, arguments);
            //添加方法 
            values.toPipedString = function () {
                return this.join("|");
            };
            //返回数组 
            return values;
        }
        var colors = new SpecialArray("red", "blue", "green");
        alert(colors.toPipedString()); //"red|blue|green"

6.稳妥构造函数模式

        function Person(name, age, job) {
            var o = new Object();

            o.sayName = function () {
                console.log(name);
            };

            return o;
        }

        var friend = Person("Nicholas", 29, "Software Engineer");
        friend.sayName(); //Nicholas

优点：安全，除了调用 sayName() 方法外，没有别的方式可以访问其name属性
缺点：无法识别对象所属类型
稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：
1. 是新创建对象的实例方法不引用 this ；
2. 是不使用 new 操作符调用构造函数