要實現(xiàn)一個標準的單例模式并不復雜，無非是用一個變量來標志當前是否已經(jīng)為某個類創(chuàng)建過對象，如果是，則在下一次獲取該類的實例時，直接返回之前創(chuàng)建的對象。代碼如下:

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

var a = Singleton.getInstance( "sven1" ); 
var b = Singleton.getInstance( "sven2" );
alert ( a === b ); // true

我們通過 Singleton.getInstance 來獲取 Singleton 類的唯一對象，這種方式相對簡單，但有 一個問題，就是增加了這個類的“不透明性”，Singleton 類的使用者必須知道這是一個單例類， 跟以往通過 new XXX 的方式來獲取對象不同，這里偏要使 Singleton.getInstance 來獲取對象。

上面單例模式的實現(xiàn)，更多的是接近傳統(tǒng)面向?qū)ο笳Z言中的實現(xiàn)，單例對象從 “類” 中創(chuàng)建而來。在以類為中心的語言中，這是很自然的做法。比如在 Java 中，如果需要某個對象，就必須先定義一個類，對象總是從類中創(chuàng)建而來的。

但 JavaScript 其實是一門無類(class-free)語言，也正因為如此，生搬單例模式的概念并無意義。在 JavaScript 中創(chuàng)建對象的方法非常簡單，既然我們只需要一個“唯一”的對象，為什 么要為它先創(chuàng)建一個“類” 呢?這無異于穿棉衣洗澡，傳統(tǒng)的單例模式實現(xiàn)在 JavaScript 中并 不適用。

1.使用命名空間

適當?shù)厥褂妹臻g，并不會杜絕全局變量，但可以減少全局變量的數(shù)量。 最簡單的方法依然是用對象字面量的方式:

var namespace1 = {
  a: function() {
    alert(1)
  },
  b: function() {
    alert(2)
  },
}

2.使用閉包封裝私有變量

這種方法把一些變量封裝在閉包的內(nèi)部，只暴露一些接口跟外界通信:

var namespace = {
  getSingleton: (function() {
    // BEGIN iife
    var singleton
    return function() {
      if (!singleton) {
        singleton = {
          amethod: function() {
            console.log("amethod")
          },
        }
      }
      return singleton
    }
  })(), // END iife
}
// Invoke: namespace.getSingleton().amethod()

ES6 里有了模塊和類的概念，實現(xiàn)起來會變得不一樣：

const singleton = Symbol();
const singletonEnforcer = Symbol();

class SingletonEnforcer {
  constructor(enforcer) {
    if (enforcer !== singletonEnforcer) {
      throw new Error("Cannot construct singleton");
    }

    this._type = "SingletonEnforcer";
  }

  static get instance() {
    if (!this[singleton]) {
      this[singleton] = new SingletonEnforcer(singletonEnforcer);
    }

    return this[singleton];
  }

  singletonMethod() {
    return "singletonMethod";
  }

  static staticMethod() {
    return "staticMethod";
  }

  get type() {
    return this._type;
  }

  set type(value) {
    this._type = value;
  }
}

export default SingletonEnforcer;

TypeScript 中有了 private等概念，實現(xiàn)起來會更加有趣。

讓我們想象一下，我們想要一個跟蹤溫度的類。在這個系統(tǒng)中，我們希望有一個入口，可以改變溫度。這就是 Singleton類 的樣子：

class Singleton {
  private static instance: Singleton;
  private _temperature: number;
  private constructor() { }
  static getInstance() {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
      Singleton.instance._temperature = 0;
    }
    return Singleton.instance;
  }
  get temperature(): number {
    return this._temperature;
  }
  set temperature(score) {
    this._temperature = score;
  }
  increaseTemperature(): number {
    return this._temperature += 1;
  }
  decreaseTemperature(): number {
    return this._temperature -= 1;
  }
}

const myInstance = Singleton.getInstance();
console.log(myInstance.temperature); // 0

上面的實現(xiàn)有一下幾點需要注意：

構(gòu)造函數(shù) constructor 前面使用了 private 修飾：這意味著我們將無法使用 new 關(guān)鍵字實例化該類。

我們首先檢查我們是否有一個類的實例 instance，如果沒有，我們將創(chuàng)建并返回實例本身。

如果使用 new 關(guān)鍵字創(chuàng)建對象：

const myInstance = new Singleton(); // Constructor of class "Singleton" is private and only accessible within the class declaration.

根據(jù)上面的例子，我們也可以訪問 temperature 屬性。現(xiàn)在讓我們設(shè)置溫度值并將其增加/減少幾次：

console.log(myInstance.temperature = 25); // 25
console.log(myInstance.increaseTemperature()); // 26
console.log(myInstance.increaseTemperature()); // 27
console.log(myInstance.decreaseTemperature()); // 26

在 java 中，單例模式根據(jù)是否 lazy loading （懶漢模式/餓漢模式）以及是否線程安全，分為很多種實現(xiàn)方式。而在 JS 中，我們不用關(guān)注線程安全的問題，因此無論是代碼復雜度還是實現(xiàn)難度都會低很多。

es6-design-patterns

Singleton pattern in ES6

The Singleton pattern in JavaScript: not needed

JavaScript設(shè)計模式與開發(fā)實踐

設(shè)計模式

Singleton Pattern in TypeScript