JavaScript 创建对象的7中模式

1.工厂模式

这种模式是用函数来封装以特定接口创建对象的细节

    function createP(name) {
        var o=new  Object();
        o.name=name;
        return o
    }
    var p3=createP("2");
    var p2=createP("1");

问题：对象识别

2.构造函数模式

function Person(name) {
       this.name=name;
       this.sayName=function () {
           console.log(this.name)
       }
    }
    var p3=new Person("2");
    var p1=new Person("1");

按照惯例，构造函数以一个大写字母开头，要创建Person 的新实例，必须使用new 操作符，将会经历以下四个步骤

1. 创建一个新的对象。
2. 将构造函数的作用域赋值给新对象（this指向对象）。
3. 执行构造函数的代码。 
4. 返回新对象。

检测对象类型instanceof

问题：创建一个对象就会创建一个function，创建多个对象就会创建多个完成相同任务的Function实例没有必要

3.原型模式 

 function Person(name) {
    }

    Person.prototype= {
        constructor:Person,
        name:"aa",

        sayName:function () {
            console.log(this.name)
        }
    }
    var p3 = new Person();

  我们每创建的每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以有特定类型的所有实例共享的属性和方法。

原型的动态性，在原型中查找值得过程是一次搜索，我们在原型所做的任何修改都能立即从实例上反映出来

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

    var p3 = new Person("2");

    Person.prototype.sayName = function () {
        console.log("aa");
    }
    p3.sayName()//aa

 但是如果重写了整个原型对象，就不一样了，调用构造函数时就会为实例添加一个指向最初原型的指针，二八原型修改为另一个对象就等于切断了构造函数与最初原型之间的联系   实例种地指针指向原型，而不是指向构造函数

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

    var p3 = new Person("2");

    Person.prototype= {
        constructor:Person,
        sayName:function () {
            console.log(this.name)
        }
    }
    p3.sayName()//error p3.sayName is not a function

问题：原型的所有属性是被很多实例共享的

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

 

function Person(name) {
    this.color=["red"]
    this.name=name;
}
Person.prototype={
    constructor:Person,
    sayName:function () {
        console.log(this.name)
    }
};
var p1=new Person("aa");
var p2=new Person("bb");
p1.color.push("green");
console.log(p1.color,p2.color);

构造函数模式用于定义实例属性，而模型用于定义方法和共享，最常用的方式。

动态原型模式

他把所有的信息都封装在构造函数中，而通过构造函数中初始化原型（尽在必要的情况下），就是检查某个应该存在的方法是否有效，来决定是否初始化原型。

function Person(name) {
  this.name = name
    // 检测say 是不是一个函数
    // 实际上只在当前第一次时候没有创建的时候在原型上添加sayName方法
    //因为构造函数执行时，里面的代码都会执行一遍，而原型有一个就行，不用每次都重复，所以仅在第一执行时生成一个原型，后面执行就不必在生成，所以就不会执行if包裹的函数，
//其次为什么不能再使用字面量的写法，我们都知道，使用构造函数其实是把new出来的对象作用域绑定在构造函数上，而字面量的写法，会重新生成一个新对象，就切断了两者的联系！
  if(typeof this.say != 'function') {
    Person.prototype.say = function(
    alert(this.name)
  }
}

寄生构造函数模式

这个模式跟工厂模式一模一样

function CreateP(name) {
    var o=new  Object();
    o.name=name;
    return o
}
var p=new CreateP("ss");

这种模式在特殊的情况下为对象创建构造函数，假设我们想创建一个具有额外方法的特殊数组，由于不能直接修改Array构造函数，因此使用这个模式

function SpecialArray() {
    var values=new Array();
    values.push.apply(values,arguments);
    values.toPipedString=function () {
        return this.join("|")
    }
    return values
}
var c=new SpecialArray("red");

稳妥构造函数模式

稳妥对象 ，指的是没有公共属性，而其他方法也不引用this的对象。稳妥对象适合在一些安全的环境中（这些环境禁止使用this和new）或防止数据被其他应用程序改动时使用。

function Person(name, age) {
    var o=new Object();
    o.sayName=function () {
        alert(name);
    }
    return o
}
var p1=Person("nicol",29);
p1.sayName()

在这个模式创建的对象中，除了使用sayName（）方法之外，没有其他方法访问name的值