JS设计模式

一、工厂模式

解决了创建过个对象的问题，但没有解决对象识别的问题（怎样知道一个对象的类型）

优点：避免创建多次对象

function Factory(n,s){
    //创建一个对象
    var obj={};
    obj.name=n;
    obj.sex=s;
    obj.sleep=function(){
        return this.name+"睡觉";
    }
    return obj;

}
console.log(Factory("lisi","男"));
console.log(Factory("张三","男"));

二、构造函数模式

直接定义函数 this(指针问题)指向当前实例对象

优点：没有返回值 没有明显的创建对象

function Page(){
    this.nowpage=1;
    this.totlepage=20;
    this.data=null;
    this.createpageLi=function(){
        console.log("构造函数模式的方法");
    }
}
//实例化对象
var page=new Page();
//直接调用方法

三、原型模式

优点：原型对象的属性方法都可以共享
省略了为构造函数传递初始化参数，结果所有实例享有相同的属性

function Person(){

}
//原型的属性和方法
Person.prototype={
    name:"",
    sex:"",
    sleep:function(m){
        return this.name+"睡觉"+m;

    }
}
var per1=new Person();
per1.name="张三";
per1.sex="男";
console.log(per1);
console.log(per1.sleep("打呼噜"));

四、单例模式

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点
核心：确保只有一个实例
实现：闭包

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

}
Person.prototype.getName=function(){
    return this.name;
}
var getObject=(function(){
    var instance=null;
    return function(info){ //闭包
        if(!instance){
            instance=new Person(info);
        }
        return instance;
    }
    //返回一个单独的对象
})()
//调用单例模式
console.log(getObject("张三").getName());//张三
console.log(getObject("李四").getName());//张三
console.log(getObject("王五").getName());//张三

这种单例只针对new Person的，那要设置多个类对象，可以把单例方法抽为一个共享方法：

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function () {
    return this.name;
}
var getInstance = function (callback) {
    var instance = null;
    //闭包
    return function () {//不写形参  直接使用arguments  集合列表

        if (!instance) {
            //实例化对象的

            /*callback 是回调函数  返回一个对象
             apply  call    替换对象的时候可以直接执行函数*/
            instance = callback.apply(this, arguments);
        }
        return instance;
    }
}

console.log(getInstance(function () {
    //这个匿名函数内部返回一个对象
    var per = new Person("李四");
    return per;
})().getName());