javaScript设计模式系列（二） 单体模式

摘要

单体模式也有人称为单例模式，是javaScript 中最基本但又最有用的模式之一。

什么是单体

一讲到概念第一反应就是WTF

其实单体模式是最常用，也是最有用的一种模式。而我们也会在项目中不知不觉的写一些单体模式，只是我们没有意识到，这也是一种设计模式。看一个简单的例子：

var zoom = {
  bird: 10,
  monkey: 10,
  play: function() {},
  eat: function() {}
}

这和我随手找的一个对象有什么区别，从严格意义上讲这确实不能称为一个单体。但我们可以分析一下这个对象，其中有两个zoom相关的属性，和两个zoom相关的方法。实际上最简单的单体就是字面量，它是把一些有一定关系的方法和属性组织在一起。

但他违背了面向对象设计的一条原则：类可以被扩展，但不应该被修改。听到这里我们也不需要慌，因为（Python，Ruby）都允许在定义了类之后对其修改。

可能你还是不知道单体与普通字面量有什么不同，那就再看一个例子：

var zoom = function() {
  var bird = 10;
  var monkey = 10;
  this.play = function() {}
  this.eat = function() {}
}
var zoom1 = new zoom();
var zoom2 = new zoom();
console.log(zoom1 === zoom2)//false;

zoom被实例化两次，但两个实例明显不相等。因为zoom1,zoom2的指针，并没有只向内存中的同一地址。这也正好可以引出单体与不同字面量的不同。按传统定义，单体是一个只能被实例化一次，并且可以通过一个众所周知的访问点访问的对象。后半句简单说，就是可以全局访问。

总结一下上面内容。单体是一个用来划分命名空间并将一批相关方法和属性组织在一起的对象，如果它可以被实例化，那么它只能被实例化一次。

与命名空间的关系

如果我们的变量都定义在全局中，一不小心别人重新用相同的变量名，定义一个变量，那我们的代码就会出问题，而且这种问题很难排查。为了避免这种不确定性，我们可以把代码组织在命名空间中（其实，就是另一个对象中，但这个对象，更具有包含性）

var ZoomSpace = {
  otherFunction: function() {}
}
ZoomSpace.zoomUtil = {
  bird: 10,
  monkey: 10,
  play: function() {},
  eat: function() {}
}

这样如果在全局中重定义了zoomUtil,我们的zoomUtil也不会受到影响。

使用构造函数

function zoomUtil() {
  //如果被实例化过，就返回实例化的结果
  if(zoomUtil.unique !== undefined) {
    return zoomUtil.unique;
  }
  var bird = 10;
  var monkey = 10;
  function play() {};
  function eat(){};
  return zoomUtil.unique = this;
}
var zoom1 = new zoomUtil();
var zoom2 = new zoomUtil();
console.log(zoom1 === zoom2)//true

这种方式比较简洁，通过判断是否已经实例化过，但是也没啥安全性，如果在外部修改zoomUtil.unique 那很可能单例模式就被破坏了。

拥有私有成员的单体

使用下划线表示

下划线表示私有成员，是约定俗称的一种方法，告诉别人不要直接访问私有方法。

使用上面我们已经定义好的命名空间：

ZoomSpace.zoomUtil = {
  bird: 10,
  monkey: 10,
  _runTime: function() {
    return ++this.bird;
  },
  play: function() {
    //return this._runTime(); 尽量不要再共有方法中使用this
    //this很可能因为此方法使用在别的函数中导致指向window
    return ZoomSpace.zoomUtil._runTime();
  },
  eat: function() {}
}
console.log(ZoomSpace.zoomUtil.play());//11

这种方法的安全性也不好，主要靠人为的约束，但是如果有人非要用我们的私有方法，导致我们删除或者修改私有方法后，他的程序不能用，只能能跟他说no zuo no die。

使用闭包

之前我们的单体都是这样的：

ZoomSpace.zoomUitl = {};

现在我们用一个立即执行的函数创建，像这样：

ZoomSpace.zoomUitl = (function(){
  return {};
})();

以往的做法是把变量和函数定义在构造函数内部。因此，每次生成一个实例，所有的方法属性都会被再次创建。这样的做法很低效。而现在的做法我们不必要担心定义的属性过多，因为它只会被实例化一次。我们来改写上面的例子：

ZoomSpace.zoomUtil = (function(){
  //私有属性和方法
  var bird = 10;
  var monkey = 10;
  function runTime(){
    return ++bird;//不需要使用this
  };
  function otherFunction(){};
  return {
    play:function(){
      return runTime();
    }
  }
})()
console.log(ZoomSpace.zoomUtil.play());//11

如果你想通过new的方式来写，可以像下面这样修改：

var ZoomSpace = {};
ZoomSpace.zoomUtil = (function() {
//私有属性和方法
  var unique; //唯一值
  function zoomUtilConstructor() {
    // 是否被实例化过
    if(unique.constructor === zoomUtilConstructor) {    
      //如果实例化过，返回已经实例化的对象
      return unique;
    }
    var bird = 10;
    var monkey = 10;
    function runTime() {
      return ++bird;
    };
    this.play = function(){
      return runTime();
    }
    // 保存实例化的对象
    return unique = this;
  }
  // 保存构造函数
  return unique = zoomUtilConstructor;
})()
var zoom1 = new ZoomSpace.zoomUtil();
var zoom2 = new ZoomSpace.zoomUtil();
console.log(zoom1 === zoom2); //true

方法有很多，具体看那种最适合。

总结

考虑否严格的只需要一个实例对象的类，那么就要考虑使用单体模式。使用数据缓存来存储该单例，用作判断单例是否已经生成，是单例模式主要的实现思路。