摘要：現在讓我們設置溫度值并將其增加減少幾次小結在中，單例模式根據是否懶漢模式餓漢模式以及是否線程安全，分為很多種實現方式。參考設計模式與開發實踐設計模式

Back in 1994, a book was authored by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides that discusses 23 desgin patterns, titled Design Patterns: Elements of Resuable Object-Oriented Software. You may have heard of this book or the authors as Gang of Four (GoF).

單例模式（Singleton Pattern）是最簡單的設計模式之一。這種類型的設計模式屬于創建型 (Creational) 模式，它提供了一種創建對象的最佳方式。

這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

注意：

單例類只能有一個實例。

單例類必須自己創建自己的唯一實例。

單例類必須給所有其他對象提供這一實例。

單例模式是一種常用的模式，有一些對象我們往往只需要一個，比如線程池、全局緩存、瀏覽器中的 window 對象等。在 JavaScript 開發中，單例模式的用途同樣非常廣泛。試想一下，當我們單擊登錄按鈕的時候，頁面中會出現一個登錄浮窗，而這個登錄浮窗是唯一的，無論單擊多少次登錄按鈕，這個浮窗都只會被創建一次，那么這個登錄浮窗就適合用單例模式來創建。

意圖：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。

主要解決：一個全局使用的類頻繁地創建與銷毀。

何時使用：當您想控制實例數目，節省系統資源的時候。

如何解決：判斷系統是否已經有這個單例，如果有則返回，如果沒有則創建。

關鍵代碼：構造函數是私有的。

我們將創建一個 SingleObject 類。SingleObject 類有它的私有構造函數和本身的一個靜態實例。

SingleObject 類提供了一個靜態方法，供外界獲取它的靜態實例。SingletonPatternDemo，我們的演示類使用 SingleObject 類來獲取 SingleObject 對象。

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

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 來獲取對象。

上面單例模式的實現，更多的是接近傳統面向對象語言中的實現，單例對象從 “類” 中創建而來。在以類為中心的語言中，這是很自然的做法。比如在 Java 中，如果需要某個對象，就必須先定義一個類，對象總是從類中創建而來的。

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

1.使用命名空間

適當地使用命名空間，并不會杜絕全局變量，但可以減少全局變量的數量。 最簡單的方法依然是用對象字面量的方式:

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

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

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

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 里有了模塊和類的概念，實現起來會變得不一樣：

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等概念，實現起來會更加有趣。

讓我們想象一下，我們想要一個跟蹤溫度的類。在這個系統中，我們希望有一個入口，可以改變溫度。這就是 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

上面的實現有一下幾點需要注意：

構造函數 constructor 前面使用了 private 修飾：這意味著我們將無法使用 new 關鍵字實例化該類。

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

如果使用 new 關鍵字創建對象：

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

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

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

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

es6-design-patterns

Singleton pattern in ES6

The Singleton pattern in JavaScript: not needed

JavaScript設計模式與開發實踐

設計模式

Singleton Pattern in TypeScript