js创建对象的7种模式 --来自js高级

js创建对象的方法：
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("lily", 29, "Engineer");
var person2 = createPerson("lucy", 20, "Student");
person1.sayName();
person2.sayName();

缺点：不知道对象类型
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(("lily", 29, "Engineer");
var person2 = new Person("lucy", 20, "Student");

缺点：每个方法都要在每个实例上重新创建一遍，造成了内存上的浪费。（这两个方法是不同的作用域链）
3.原型模式；

function Person() {

}
Person.prototype.name = "hehe";
Person.prototype.age = 29;
Person.prototype.job = "Engineer";
Person.prototype.sayName = function() {
    alert(this.name);
}
var person1 = new Person();
person1.name = "lily";
person1.sayName();
var person2 = new Person();
person2.sayName();

上面每添加一个属性和方法都需要.prototype.，封装性不好，故做如下改进(重写构造函数,此时，)：

function Person() {

}
Person.prototype = {
    constructor: Person, // 会导致[[Enumerable]]属性被设置为true
    name: "hehe",
    age: 29,
    friends: ["HanMeimei", "LiLei"],
    sayName: function() {
        alert(this.name);
    }
}
Person.prototype.age = 29;
Person.prototype.job = "Engineer";
Person.prototype.sayName = function() {
    alert(this.name);
}
var person1 = new Person();
person1.friends.push("Susan");
var person2 = new Person();
console.log("person2.friends:",person2.friends);

缺点：由于原型模式就是多个实例共享属性和方法的，那么针对引用类型的属性而言，多个实例的引用类型是会相互影响的
4.组合使用构造函数模式和原型模式:这是一般常用的方式，用构造函数定义实例属性，用原型创建公共属性和方法：

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["HanMeimei", "LiLei"];
}
Person.prototype = {
    constructor: Person,
    sayName: function() {
        alert(this.name);
    }
}
var person1 = new Person();
person1.friends.push("Susan");
var person2 = new Person();
console.log("person2.friends:",person2.friends);

这样引用类型的属性便不会有问题了。
缺点：上述没有面向对象，构造函数和原型是分开的，没有将其封装。而动态原型模式就可以解决此问题。
5.动态原型模式；此方式就是完美的，也常用

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["HanMeimei", "LiLei"];
    if (typeof this.sayName !== "function") { // 确保在多个实例初始化时只创建一次
        Person.prototype.sayName = function() { // 此处不能重写原型，会切换了实例与原型之间的联系
            alert(this.name);
        };
        Person.prototype.sayAge = function() {
            alert(this.name);
        };
    }
}
var person1 = new Person();
person1.friends.push("Susan");
var person2 = new Person();
console.log("person2.friends:",person2.friends);

6.寄生构造函数模式；
与工厂模式比较类似,当其他模式都不能用的时候，再采用寄生构造函数模式，可以用其为对象创建构造函数

function Person(name, age, job) { //与工厂模式的区别 此处是构造函数，然后new 出来的
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function() {
        alert(this.name);
    }
    return o;
}
var person1 = new Person("HanMeimei", 29, "Engineer");
person1.sayName();

e.g.为对象创建构造函数

function SpecialArray() {
    var arr = new Array();
    arr.push.apply(arr, arguments);
    arr.toPipedString = function() {
        return this.join("|");
    }
    return arr;
}
var colors = new SpecialArray("red", "yellow");
console.log("colors:",colors.toPipedString());
7.稳妥构造函数模式:就是没有this的概念，属性只能从方法中获取，这适合在安全执行环境中使用.
function Person(name, age, job) {
    var o = new Object();
    o.sayName = function() {
        alert(name)
    }
    return o;
}
var person1 = Person("hehe");
person1.sayName();

工厂模式、寄生构造函数模式与稳妥构造函数模式很类似