定义：一个类仅有一个实例，并提供一个访问它的全局访问点

实现思路：通过一个变量判断是否已经创建过对象了，如果是，直接返回此变量。

基础实现

  1. /**
  2.  * 单例模式基础实现
  3.  * 缺点：没有透明化
  4.  * @param {String} name 
  5.  */
  6. var Singleton = function (name) {
  7.     this.name = name
  8. }
  10. Singleton.prototype.getName = function () {
  11.     console.log(this.name)
  12. }
  14. Singleton.getInstance = function (name) {
  15.     var instance = null
  16.     return function (name) {
  17.         if (!instance) {
  18.             instance = new Singleton(name)
  19.         }
  20.         return instance
  21.     }
  22. }
  24. var a = Singleton.getInstance('test1')

使用代理类实现单例模式

  1. var CreateDiv = function (html) {
  2.     this.html = html
  3.     this.init()
  4. }
  6. CreateDiv.prototype.init = function () {
  7.     var div = document.createElement('div')
  8.     div.innerHTML = this.html
  9.     document.body.appendChild(div)
  10. }
  13. // 使用代理实现单例模式
  15. var ProxySingletonCreateDiv = (function () {
  16.     var instance
  17.     return function (html) {
  18.         if (!instance) {
  19.             instance = new CreateDiv(html)
  20.         }
  22.         return instance
  23.     }
  24. })()
  26. var a = new ProxySingletonCreateDiv('test1')

惰性单例

在需要的时候才会创建实例，并且只创建一个实例

通常会把创建对象和管理实例职责分开，以达到组件复用的作用

  1. /**
  2.  * 
  3.  * 创建对象和管理单例的职责要分开
  4.  */
  5. var getSingle = function (fn) {
  6.     var result
  7.     return function () {
  8.         return result || (result = fn.apply(this, arguments))
  9.     }
  10. }
  12. var createLoginLayer = function () {
  13.     var div = document.createElement('div')
  14.     div.innerHTML = '我是浮窗'
  15.     div.style.display = 'none'
  16.     document.body.appendChild(div)
  17.     return div
  18. }
  20. var createSingleLoginLayer = getSingle(createLoginLayer)