设计模式

构造函数模式

利用原型继承的方式创建对象，以实现功能

function People(name,age) {
    this.name = name;
    this.age = age;
    this.init();
}
People.prototype = {
    sayHello:function () {
        console.log("I'm" + this.name + ",hello!")
    },
    init:function () {
        this.sayHello();
    }
};

var xiaoming = new People("xiaoming",18);

混合模式

本质上也是利用原型继承的方式创建对象，但更加具象了功能的分层。

function People(name) {
    this.name = name;
    this.init();
}
People.prototype = {
    sayHello:function () {
        console.log("I'm" + this.name + ",hello!")
    },
    init:function () {
        this.sayHello();
    }
};
function Student(name,grade){
    People.call(this,name);                                   //让People中的this.name变为由Student传入的name
    this.grade = grade;
}
Student.prototype= Object.create(People.prototype);    //继承父对象
Student.prototype.sayGrade = function () {
    console.log("my grade is" + this.grade);
};
Student.prototype.init = function () {
    this.sayHello();
    this.sayGrade();
};

var xiaoming = new Student("xiaoming","A");

模块模式

利用闭包，将私有变量保存，是一种很常见的封装方式，但是隐私性做的不够好。

var Student = (function () {
    var name = "xiaoming"
    var gender = "male";
    function sayHello() {
        console.log("my name is " + name);
    }
    function sayGender(){
        console.log("my gender is " + gender);
    }
    return {
        sayHello:sayHello,
        sayGender:sayGender
    }
})();
Student.sayGender();

工厂模式

建立一个功能丰富的函数，将参数传入函数以实现不同的功能

function People(gender){
    function Male(gender){
        this.gender=gender;
        this.name="Kevin";
    }

    function Female(gender){
        this.gender=gender;
        this.name="Daisy";
    }

    var result=undefined;
    if(gender.toLowerCase() == "male"){
        result = new Male(gender);
    }
    if(gender.toLowerCase() == "female"){
        result = new Female(gender);
    }
    return result;
}
People("male").name; 

单例模式

利用闭包的思想保存私有变量，同时为了节省空间，利用构造函数的方法仅仅在调用时才创造新对象 。最重要的是，对象只能构造一次，无法通过反复调用函数更改属性。

var SingletonTester = (function () {

    //参数：传递给单例的一个参数集合
    function Singleton(args) {

        //设置args变量为接收的参数或者为空（如果没有提供的话）
        var options = args || {};
        //设置name参数
        this.name = 'SingletonTester';
        //设置pointX的值
        this.pointX = args.pointX || 6; //从接收的参数里获取，或者设置为默认值
        //设置pointY的值
        this.pointY = args.pointY || 10;

    }

    //实例容器
    var instance;

    return {

        //获取实例的方法
        //返回Singleton的实例
        getInstance: function (args) {
            if (!instance) {
                instance = new Singleton(args);
            }
            return instance;
        }
    };
})();

var singletonTest = SingletonTester.getInstance({ pointX: 5 });
console.log(singletonTest.pointX); // 输出 5
var singletonTest = SingletonTester.getInstance({ pointX: 10 });
console.log(singletonTest.pointX); // 输出5

发布订阅模式

该模式用一个自己写的事件模块来连接多个独立模块，实现不同模块之间的解耦。例如，轮播跳转的同时实现文字的跳转，为了保持轮播模块的独立性，不想把关联文字跳转的代码写入轮播模块中，这时我们就可以用这种方法记录“轮播跳转”，然后在文字跳转这个模块中实现功能。类似于事件监听，时间管理器代码如下：

var EventManager = (function () {
    //创建一个记录事件的集合
    var events = {};
    return {
        //添加事件
        on:function (item,func) {
            events[item] = events[item] || [];
            events[item].push(func);
            return this;
        },
        //触发事件
        fire:function (item) {
            if(!events[item])return;
            for(var i = 0; i < events[item].length; i++){
                events[item][i]([].slice.call(arguments,1));
            }
            return this;
        },
        //删除事件
        off:function (item) {
            if(events[item]){
                delete events[item];
            }
            return this;
        }
    }
})();
EventManager.on('text:change', function(val){
    console.log('text:change...  now val is ' + val);
});
EventManager.fire('text:change', '饥人谷');       //text:change...  now val is 饥人谷
EventManager.off('text:change');

写一个函数createTimer，用于创建计时器，创建的计时器可分别进行计时「新增」

function createTimer() {
    var clock;
    var i = 0;
    function start() {
        clock = setInterval(function () {
            i++;
            console.log(i);
        },1000)
    }
    function get() {
        return i;
    }
    function end() {
        clearInterval(clock);
    }
    return {
        start:start,
        get:get,
        end:end
    }
}