Typescript 單體/單例模式

標籤： 前端 設計模式 單體模式 單例模式 typescript

---

如果下面的代碼你能輕易閱讀，那麼你已經熟悉單體模式，可以接着學習其他的設計模式。

前言

設計模式（Design Pattern）是一套被反覆使用、多數人知曉的、經過分類的、代碼設計經驗的總結。
使用設計模式的目的：爲了代碼可重用性、讓代碼更容易被他人理解、保證代碼可靠性。 設計模式使代碼編寫真正工程化；
設計模式是軟件工程的基石脈絡，如同大廈的結構一樣。

單體模式

我們在描述一類物體的時候常常根據其特性定義這類物體的個體。這些個體之間總是有一定的聯繫。
例如：我們的汽車商店需要存儲一些汽車。

• 我們可以將他們放到全局

var bus,babyCar,crossCountryCar,minibus

這樣我們在全局存儲了4個變量，而且會隨着汽車種類的增多增加變量的個數，維護成本越來越高。

• 將它們放在一個作用域中

var carType = {
   bus,
   babyCar,
   crossCountryCar,
   minibus
}

經過前人的總結，這樣寫是有利於後期的維護的。這也就是最簡單的單體模式。

單體模式的特點

1. 該類只有一個實例
2. 該類自行創建該實例(在該類內部創建自身的實例對象)
3. 向整個系統公開這個實例接口

單體模式的兩種創建方式

首先我們定義單體模式需要實現的接口

/* i-car-shop.ts */
export default interface ICarShop {
    bus(): string
    babyCar(): string
    minibus(): string
    crossCountryCar(): string
}

• 初始化時創建
  在初始化時創建好單體對象，隨時使用。

/* singleton.ts */
import ICarShop from './i-car-shop';
class CarShop implements ICarShop {
    private static _instance: CarShop = new CarShop();
    public static getInstance() {
        return this._instance;
    }
    public bus(): string {
        return 'bus';
    }
    public babyCar(): string {
        return 'babyCar';
    }
    public minibus(): string {
        return 'minibus';
    }
    public crossCountryCar(): string {
        return 'crossCountryCar';
    }
}
export default CarShop;

• 在第一次調用時創建(lazy loading)
  在我們使用到該單體的時候進行創建，避免佔用沒必要的空間。

/* lazy-load.ts */
import ICarShop from './i-car-shop';
class CarShop implements ICarShop {
    private static _instance: CarShop;
    public static get instance() {
        if (!this._instance) {
            this._instance = new CarShop();
        } else {
            console.log('lazy loading singleton has created')
        }
        return this._instance;
    }
    public bus(): string {
        return 'bus';
    }
    public babyCar(): string {
        return 'babyCar';
    }
    public minibus(): string {
        return 'minibus';
    }
    public crossCountryCar(): string {
        return 'crossCountryCar';
    }
}
export default CarShop;

分支

分支技術是把差異化輸出放到運行時去判斷。
例如：現在需要根據當前的時間獲取當前應該乾的事情。用分支技術動態獲取結果如下。

export default class TimeHelper {
    private static _instance: TimeHelper = new TimeHelper();
    constructor() {
        return TimeHelper._instance;
    }
    public static getInstance() {
        return this._instance;
    }
    public get nowTime() {
        let hours = new Date().getHours();
        if (hours <= 9) {
            return this._morning();
        } else if (hours <= 13) {
            return this._noon();
        } else if (hours <= 18) {
            return this._afternoon();
        } else if (hours <= 23) {
            return this._evening();
        }
    }
    private _morning() {
        return {
            time: 'morning',
            toDo: 'reading',
        };
    }
    private _noon() {
        return {
            time: 'noon',
            toDo: 'sleeping',
        };
    }
    private _afternoon() {
        return {
            time: 'afternoon',
            toDo: 'working',
        };
    }
    private _evening() {
        return {
            time: 'evening',
            toDo: 'running',
        };
    }
}

使用時調用

new TimeHelper().nowTime
或
TimeHelper.getInstance().nowTime

去獲取當前應該做的事情。

單體模式的優劣

優點：

1. 組織作用 ：單體模式的主要好處在於它對代碼的組織作用。把相關方法和屬性組織在一個不會被多次 實例化 的單體中，可以使代碼的調試和維護變得更輕鬆哦......

2. 節約內存 ：同第一條所講，單體模式只會被實例化一次，節約內存。

3. 防止被誤改 ：把方法包裹在單體中，可以防止它們被其他 程序猿 誤改。

單體模式的一些高級變體可以在開發後期用於對腳本進行優化，提高性能：

使用惰性實例化技術，可以直到需要一個對象的時候才創建它，從而減少那些不需要它的用戶承受的不必要的內存消耗（還可能包括帶寬消耗）。

分支技術可以用來創建高效的方法，不用管瀏覽器或者環境的兼容性。通過根據運行時的條件確定賦給單體變量的對象字面量，你可以創建出爲特定環境量身定製的方法，這種方法不會在每次調用時都浪費時間去檢查運行環境。

壞處：

由於單體模式提供的是一種單點訪問，所以它有可能導致模塊間的 強耦合 。又因爲這種強耦合導致它不利於單元測試。（你無法單獨測試一個調用了來自單體的方法的類，只能把它和那個單體作爲一個單元一起測試....）