闭包实现面向对象设计

闭包的思想是: 一个函数想用一个引用一个外部变量，但是有不想让这个变量暴露在全局环境中，那么就使用闭包。闭包一般有两种使用形式，一个是立即执行的闭包，一种是用时执行的闭包。两种有和区别呢？
立即执行的闭包，用于全局创建一个闭包对象
用时执行的闭包，可用于全局创建多个闭包对象

//立即执行的模式
var matchEmail = (function() {
  var regx = /^\w+(\.\w+)*@\w+\.\w{2,3}(\.\w{2,3})?$/;
  return function(email) {
      return regx.test(email);
  }
})();

console.log(matchEmail('535.fu@qq.com'));

//用时执行的模式

var matchEmail2 = function() {
  var regx = /^\w+(\.\w+)*@\w+\.\w{2,3}(\.\w{2,3})?$/;
  return function(email) {
      return regx.test(email);
  }
}

var matchEmail2 = matchEmail2();
console.log(matchEmail('535.fu@qq.com'));

两者有啥区别呢？容易看出，用时执行模式，每次在创建一个新的matchEmail2时候，都会新建一个闭包，和创建一个新的 regx
立即执行啥时候用呢？ 一般是在封装的遍历在函数引用中都是有同一个时，如果不同情况需要使用多个，那么使用 用时执行
很显然，我们如果想要创建一个对象系统的话，需要用用时执行模式

var Events = function() {
  var handlers = {};
  var subscribe = function(type, handler) {
    if (!handlers[type]) {
      handlers[type] = [];
    }
    handlers[type].push(handler);

    //存储当前这个handler是否被订阅
    var isSubscribed = true;
    //每次执行一个订阅函数，返回一个取消订阅回调，只要使用这个函数，那么就取消
    return function unsubscribe() {
      if (!isSubscribed) return; //防止多次执行
      isSubscribed = false;
      const index = handlers[type].indexOf(handler);
      handlers[type].splice(index, 1);
    }
  }

  function dispatch(type) {
    if (handlers[type]) {
      for (let i = 0; i < handlers[type].length; i++) {
        handlers[type][i]();
      }
    }
  }


  //闭包对象系统，返回一个对象
  return {
    subscribe,
    dispatch
  }
}

//创建一个event对象
var event = Events();
//创建另外一个event对象
var event1 = Events();

var unSubscribe = event.subscribe('click', function() {console.log('event click')});
event1.subscribe('click', function() {console.log('event1 click')});


event.dispatch('click');
event1.dispatch('click');
unSubscribe();
event.dispatch('click');

上面创建的两个对象 event event1 互不干扰
利用闭包创建对象系统的话，利用闭包封装想用的局部变量，然后返回一个对象，对象里面是向外提供的接口

tips:上面的订阅一个函数，然后返回一个取消点阅函数，也是一种非常不错的发布　取消点阅模式中的编程思想哦，利用闭包，在订阅的时候就封闭了订阅时的函数，那么取消点阅的时候，就一定能访问到这个函数