创建对象的模式

---

1. 工厂模式

function creatP(name,age){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.sayName = function{
        alert(this.name);
    };
    return o;
}
var p1 = creatP('hulala',12);

2. 构造函数模式

function Foo() {
   this.value = 'Foo';
}

• 所有属性和方法都是在构造函数内部通过this关键字定义
• Foo(),此时this对象为window
• new Foo(),this指向新对象，再执行构造函数，将其中的属性和方法赋值给新对象，最后返回新对象

构造函数模式缺点：每个方法都要在实例上重新创建一遍。

3. 原型模式

function Foo() {}
Foo.prototype.value = 'FooProto'

• 所有属性和方法都是通过prototype关键字定义的

原型模式缺点：实例对象对原型对象上属性和方法时共享的，因此若原型对象上包含引用类型属性时，一个实例对象对这个引用类型的修复 会体现在另一个实例对象上

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

function Foo() {
      this.value = 'Foo';
}
Foo.prototype.value = 'FooProto';

而对于var f = new Foo(),f.value的查找顺序为：

1. 先查找f这个实例本身（实例本身属性会覆盖构造函数执行时赋值给实例的属性）
2. 由于构造函数中的属性是直接赋值给对象的，而对象的__proto__属性是指向构造函数的原型对象的，所以构造函数中的属性相当实例本身属性，因此再查找构造函数的属性
3. 最后查找原型链上的属性
4. 构造函数上直接定义的静态属性不会继承下来

5. 动态原型模式

在构造函数初始化时检查原型链是否存在某个方法，若不存在，添加到原型上即可:

function Foo() {
        this.value = 'Foo';
        if(typeof this.sayValue != 'function'){
            Foo.prototype.sayValue = function(){
                console.log(this.value);
            }
        }
    }
    var foo1 = new Foo();
    foo1.sayValue();//Foo

6. 寄生构造函数模式

在构造函数中创建空对象，同时为这个空对象添加属性和方法，最后返回这个对象，除过用new新建对象并把这个函数叫做构造函数外和工厂模式无区别：

 function SpecialArray() {
        var arr = new Array();
        arr.push.apply(arr,arguments);
        arr.splitPipe = function () {
            return arr.join('|');
        };
        return arr;
    }
    var a = new SpecialArray('1','3','4');
    a.splitPipe();//"1|3|4"
var b = SpecialArray('1','3','4');
    b.splitPipe();//"1|3|4"

7. 稳妥构造函数模式

构造函数中不用this，创建新对象不用new，

function Foo(name) {
        var o  = new Object();
        o.sayName = function () {
            console.log(name);
        };
        return o;
    }
    var f = Foo('zy');
    f.sayName();//zy

Foo中保存的是稳妥的对象，除过sayName方法外，没有其他访问name的方法。