JavaScript设计模式二（单例模式）

JavaScript设计模式二（单例模式）

这边文章主要是JavaScript中的单例模式
定义：

保证一个类仅有一个实例，并提供一个访问它的全局访问点

其实我们的日常开发中或多或少的用到了单例模式的方法。例如我们做Electron开发的过程中，点击一个按钮创建了一个窗口，后续点击的时候，如果窗口已经存在了就focus窗口，否则创建；或者我们经常会创建一个定时任务，同时把定时任务赋值给一个变量，如果变量不存在就创建，否则不创建。但是大多数情况我们都是利用的是一个变量来控制的。接下来我们看看代码的实现

实现单例模式

其实上面的介绍我们已经说了实现单例模式的思路，就是通过一个变量来控制

var Singleton=function(name) {
    this.name=name;
    this.instance=null;
}
Singleton.prototype.getName=function(){
    console.log(this.name);
}
Singleton.getInstance=function(name) {
    if(!this.instance) {
        this.instance = new Singleton(name);
    }
    return this.instance;
}

//这种写法借助了this.instance，其实可以不需要

var Singleton = function(name) {
    this.name=name;
}
Singleton.prototype.getName=function(){
    console.log(this.name);
}
Singleton.getInstance=(function(){
    var instance = null;
    return function(name) {
        if(!instance) {
            instance = new Singleton(name);
        }
        return instance;
    };
})();

使用方法：

var a = Singleton.getInstance('a');
var b = Singleton.getInstance('b');
a===b

这种方式实现了我们说的单例模式，但是有一个很明显的缺点，就是我们实例化的时候不是使用的new方法来实例化，而是用的getInstance方法，也就是说我们必须知道这个类是单例类，才能这样去用，这就增加了不透明性。

透明的单例模式

所谓的透明的单例模式，就是我们可以像正常的类那样去new一个单例类。

var CreateDiv = (function(){
    var instance;
    var CreateDiv = function(html) {
        if (instance) {
            return instance;
        }
        this.html = html;
        this.init();
        return instance = this;
    };

    CreateDiv.prototype.init = function() {
        var div = document.createElement('div');
        div.innerHTML = this.html;
        document.body.appendChild('div');
    };

    return CreateDiv;
})();

var a = new CreateDiv('div');
var b = new CreateDiv('div');

a===b

之所以能够通过new来创建一个单例类的实例，是因为CreateDiv
的返回值是一个构造函数，这个构造函数做了两件事情

• 创建对象和执行init方法
• 保证只有一个对象

我们可以想象如果需求变成了，我们需要CreateInput之类，是不是一直要修改这个类呢？

代理实现单例模式

利用代理就可以很好的解决上面的问题

var CreateDiv = function(html) {
    this.html = html;
    this.init();
}

CreateDiv.prototype.init = function() {
   var div = document.createElement('div');
   div.innerHTML = this.html;
   document.body.appendChild('div');
};

var ProxySingletonCreateDiv = (function(){
    var instance;
    return function(html) {
        if (!instance) {
            instance = new CreateDiv(html);
        }
        return instance;
    }
})();


var a = new ProxySingletonCreateDiv('div');
var b = new ProxySingletonCreateDiv('div');

利用代理类，我们遵循了单一职责的原则，让代理类负责单例的逻辑，CreateDiv变成一个普通的创建html的类，两者结合达到单例模式的效果

JavaScript中的单例模式

JavaScript单例模式的核心是：

确保只有一个实例，并提供全局访问

与传统的面向对象语言不一样，JavaScript可以定义全局变量，而且我们通常认为全局变量就是一个单例，但是这种使用方式很容易造成命名空间的污染，针对这种问题有两种办法

• 使用命名空间
  最简单的就是使用字面量常量：

var namespace1 = {
    a: function(){},
    b: 'bbbb'
}

• 利用闭包封装变量

var user = (function(){

    var _user = 'hahaha';
    return {
        setUserName: function(name) {
            _user = name;
        },
        getUserName: function(){
            console.log(_user);
        }
    }
})();

惰性单例

定义:

惰性单例是指需要时才创建的单例

上面的那几种方法实际上就是惰性单例，但是那些事面向对象的，我们看看JavaScript中的惰性单例，看一段PC版的代码吧

let historyWindow = null;
ipc.on(cfg.CHANNEL.LOCAL.CHAT.SEARCH_HISTORY, function(event, arg) {
  if (!historyWindow) {
    historyWindow = new BrowserWindow({
      width: 621,
      height: 540,
      minWidth: 621,
      minHeight: 540,
      frame: false,
      show: false,
    });
    historyWindow.setAutoHideMenuBar(false);
    historyWindow.loadURL('file://' + __dirname + '/../../../client/views/history.html');
    if (process.env.NODE_ENV == 'dev') {
      historyWindow.webContents.openDevTools();
    }
    historyWindow.on('close', function() {
      historyWindow.webContents.closeDevTools();
    });
    historyWindow.on('closed', function() {
      glb.set(cfg.GLB.HISTORY_WINDOW, null);
      glb.remove(cfg.GLB.ADD_MEMBER_WINDOW);
      historyWindow = null;
    });
    historyWindow.webContents.on('did-finish-load', function() {
      glb.set(cfg.GLB.HISTORY_WINDOW, historyWindow);
      historyWindow.show();
      historyWindow.focus();
      historyWindow.webContents.send(cfg.CHANNEL.LOCAL.CHAT.OPEN_HISTORY_WINDOW_RECV, arg);
    });
  } else {
    historyWindow.webContents.send(cfg.CHANNEL.LOCAL.CHAT.OPEN_HISTORY_WINDOW_RECV, arg);
    if (historyWindow.isMinimized()) {
      historyWindow.show();
    } else {
      historyWindow.focus();
    }
  }
});

这段代码的逻辑是，点击历史消息的icon，创建一个历史消息的弹出框，后面如果继续点击，就把之前的弹出框focus。

这里其实还有优化的空间，我们知道electron创建一个新的BrowserWindow是很慢的，所以我们创建一次之后，用户点击关闭，其实可以隐藏起来，并不是实际的关闭，这样当用户点击第二次的时候就省略了创建窗口的过程，直接渲染数据就可以。