TypeScriptでシングルトンパターンを完璧に使う10の方法

TypeScriptのシングルトンパターンの解説と実装方法 TypeScript

 

【サイト内のコードはご自由に個人利用・商用利用いただけます】

このサービスはSSPによる協力の下、運営されています。

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

基本的な知識があればカスタムコードを使って機能追加、目的を達成できるように作ってあります。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を凌駕する現役のプログラマチームによって監修されています。

サイト内のコードを共有する場合は、参照元として引用して下さいますと幸いです

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

はじめに

プログラミングの世界において、デザインパターンは、特定の問題を解決するための一般的な再利用可能なソリューションを提供します。

その中でも、シングルトンパターンは、アプリケーションで一つのインスタンスしか存在しないことを保証するためのパターンとして知られています。

この記事では、TypeScriptでのシングルトンパターンの完璧な使用法を、初心者の方でも理解し実装できるように10の方法で詳しく解説します。

各ステップには詳細なサンプルコード付きで、実際の実行結果と共に説明を行います。

TypeScriptは、JavaScriptに静的型付けとクラスベースのオブジェクト指向プログラミングを追加するための言語です。

それにより、シングルトンパターンのようなデザインパターンをより簡単に、そして型安全に実装することができます。

●シングルトンパターンとは

シングルトンパターンは、クラスが一つのインスタンスしか持たないことを保証するオブジェクト指向のデザインパターンの一つです。

このパターンの主な目的は、クラスのインスタンス化を制御し、アクセスを制限することで、システム全体で一貫性を保つことにあります。

例えば、設定情報を持つクラスや、システム内でのリソースのアクセスを管理するクラスなど、一つのインスタンスだけが存在することが望ましい場合に利用されます。

○デザインパターンの基本理解

デザインパターンは、ソフトウェア開発における一般的な問題に対する再利用可能なソリューションです。

これらのパターンは、過去のソフトウェア開発の経験から洗練されてきました。

シングルトンパターンは、これらデザインパターンの中でも特に「生成に関するパターン」に分類されます。

●TypeScriptでのシングルトンパターンの基本

TypeScriptでは、シングルトンパターンを実装するのは比較的簡単です。

クラスのプライベートコンストラクタと、そのクラスのインスタンスを持つ静的なプロパティを使用することで、シングルトンパターンの要件を満たすことができます。

○シングルトンパターンの特徴

  • インスタンスが一つしか存在しないことを保証します。
  • インスタンスへのアクセス点を提供します。
  • 適切に実装されたシングルトンは、サブクラス化が容易です。

○TypeScriptでの基本的なシングルトンの構造

このコードでは、TypeScriptを使ってシングルトンの基本的な構造を表しています。

この例では、プライベートコンストラクタを持つSingletonクラスを定義して、そのインスタンスを静的なプロパティとして保持しています。

class Singleton {
    private static instance: Singleton;

    // コンストラクタをprivateにすることで、外部からのインスタンス化を防ぎます。
    private constructor() {}

    // インスタンスへのアクセスポイントを提供します。
    public static getInstance(): Singleton {
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }
}

const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2);  // true

上記のコードを実行すると、instance1instance2は同じインスタンスを参照しているため、コンソールにはtrueが表示されます。

これにより、シングルトンパターンが正しく実装されていることが確認できます。

●シングルトンパターンの使い方: 10の方法

シングルトンパターンは、アプリケーション内で一つのインスタンスしか存在しないことを保証するためのデザインパターンです。

特定のクラスが一度だけインスタンス化され、そのインスタンスがシステム全体で共有されることがこのパターンの要点です。

それでは、TypeScriptでのシングルトンパターンの実装方法やその活用方法を10の方法で詳しく解説します。

○サンプルコード1:基本的なシングルトンの実装

このコードでは、シングルトンの基本的な構造を表しています。

この例では、プライベートコンストラクタを持つSingletonクラスを定義し、そのインスタンスを静的なプロパティとして保持しています。

class Singleton {
    private static instance: Singleton;

    private constructor() {}

    public static getInstance(): Singleton {
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }
}

const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2);

このコードを実行すると、instance1instance2が同じインスタンスを参照していることが確認でき、コンソールにはtrueが表示されます。

これは、シングルトンパターンが正しく実装されていることを示しています。

○サンプルコード2:遅延初期化を利用したシングルトン

遅延初期化は、シングルトンのインスタンスが必要になるまで生成を遅延するテクニックです。

これにより、リソースの使用を最小限に抑えることができます。

下記のコードでは、遅延初期化を実現しています。

class LazySingleton {
    private static instance: LazySingleton;

    private constructor() {}

    public static getInstance(): LazySingleton {
        if (!this.instance) {
            this.instance = new LazySingleton();
        }
        return this.instance;
    }
}

// この時点ではSingletonのインスタンスは生成されていません。
let lazyInstance: LazySingleton | null = null;

// 必要になった時にのみインスタンス化
lazyInstance = LazySingleton.getInstance();

lazyInstanceが必要となるまで、LazySingletonのインスタンスは生成されません。

必要になった時点で初めてインスタンスが生成されます。

○サンプルコード3:スレッドセーフなシングルトンの実装

TypeScriptはJavaScriptの上に構築されており、JavaScriptは基本的にシングルスレッドですが、Web WorkersやNode.jsでのマルチスレッド処理を考慮する場合、スレッドセーフなシングルトンの実装が求められることもあります。

下記のコードは、スレッドセーフなシングルトンの一例として、ダブルチェックロックを使用しています。

class ThreadSafeSingleton {
    private static instance: ThreadSafeSingleton | null = null;
    private static mutex: any = {};

    private constructor() {}

    public static getInstance(): ThreadSafeSingleton {
        if (!this.instance) {
            synchronized(this.mutex, () => {
                if (!this.instance) {
                    this.instance = new ThreadSafeSingleton();
                }
            });
        }
        return this.instance;
    }
}

const threadSafeInstance1 = ThreadSafeSingleton.getInstance();
const threadSafeInstance2 = ThreadSafeSingleton.getInstance();

console.log(threadSafeInstance1 === threadSafeInstance2);

上記のコードでは、synchronized関数を使用してクリティカルセクションを保護しています。

この結果、threadSafeInstance1threadSafeInstance2が同じインスタンスを参照していることが確認でき、コンソールにはtrueが表示されます。

○サンプルコード4:モジュールを使用したシングルトン

TypeScriptの強力な機能の1つとして、モジュールシステムが挙げられます。

このモジュールを活用することで、シングルトンパターンの実装も非常に簡単になります。

実際に、TypeScriptのモジュールは、1つのインスタンスしか生成されないため、自然にシングルトンの特性を持っています。

このコードでは、モジュールを利用してシングルトンパターンを実装する方法を表しています。

この例では、クラスではなく、モジュール内でデータとメソッドを管理して、シングルトンを構築しています。

// singletonModule.ts
export const singletonData = {
  name: "シングルトンモジュール",
};

export function displayData() {
  console.log(singletonData.name);
}

上記のコードを使用する際は、次のようにインポートして利用します。

import { singletonData, displayData } from "./singletonModule";

displayData();  // シングルトンモジュールと表示されます。

この方法であれば、同じモジュールを何度インポートしても、常に同じデータとメソッドにアクセスすることが保証されます。

しかし、この方法には注意点があります。

モジュール自体がシングルトンの性質を持っているため、意図しないシングルトンが発生する場面も考えられます。

そのため、モジュールを使用したシングルトンの実装を選択する際には、その特性を理解して活用する必要があります。

応用例として、このモジュールシングルトンは複数のデータやメソッドをまとめて管理するための設定ファイルや共通処理など、アプリケーション全体で共有したい情報を持たせるのに適しています。

// configModule.ts
export const appConfig = {
  apiUrl: "https://api.example.com",
  version: "1.0.0",
};

export function displayConfig() {
  console.log(`API URL: ${appConfig.apiUrl}, Version: ${appConfig.version}`);
}

上記のコードを使用する際は、次のようにインポートして利用できます。

import { appConfig, displayConfig } from "./configModule";

displayConfig();  // API URL: https://api.example.com, Version: 1.0.0と表示されます。

このように、モジュールを使用したシングルトンパターンは、特定の設定や共通の処理を一箇所で管理することができ、アプリケーションの保守性や拡張性も向上します。

○サンプルコード5:クラス内部でのシングルトンの実装

TypeScriptでシングルトンパターンを理解し、実装する方法を学ぶ過程で、一つの重要なテクニックは、クラス内部でシングルトンを実装する方法です。

この手法は、シングルトンの実装をさらにカプセル化して、外部からの不適切なアクセスを防ぐために有効です。

このコードでは、シングルトンの実装をクラスの内部に隠蔽する方法を表しています。

この例では、静的メソッドと静的プロパティを利用して、クラス内部でインスタンスの生成と取得を行っています。

class Singleton {
    // シングルトンのインスタンスを格納するための静的プロパティ
    private static instance: Singleton | null = null;

    // プライベートコンストラクタ: 外部からnewキーワードでの生成を制限
    private constructor() {}

    // シングルトンインスタンスを取得するための静的メソッド
    public static getInstance(): Singleton {
        // すでにインスタンスが存在する場合はそれを返す。存在しない場合は新たに生成
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }
}

// 使用例
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2);  // trueを返すことで、同じインスタンスであることを確認

上記のコードは、Singleton クラスの静的プロパティ instance を利用して、シングルトンインスタンスを保持します。

外部から直接インスタンスを生成することはできませんが、getInstance 静的メソッドを通じて、インスタンスを取得することができます。

この実装のメリットは、シングルトンの実装がクラス内に完全に隠蔽されているため、外部からの不正な操作を防ぐことができる点です。

コードの最後にある使用例では、2つのインスタンスを取得して、それらが同じインスタンスであることを確認しています。

結果として、console.log(instance1 === instance2);true を出力します。これにより、シングルトンとして正しく機能していることが確認できます。

注意点として、この手法はTypeScriptの特性を活かしたものなので、他の言語でのシングルトンパターンの実装とは少し異なる点があります。

しかし、この方法はTypeScriptの特性を最大限に活用し、より堅牢なシングルトンの実装を可能にします。

○サンプルコード6:プライベートコンストラクタの利用

TypeScriptのシングルトンパターンをより確実に実装するには、プライベートコンストラクタを活用する方法があります。

通常、クラスのコンストラクタは外部からアクセス可能ですが、プライベートコンストラクタを使用することで、クラス外部からのインスタンス化を防止し、シングルトンパターンの厳格性を保つことができます。

このコードでは、プライベートコンストラクタを使って、シングルトンパターンを適用する方法を表しています。

この例では、SingletonClassというクラス内でシングルトンのインスタンスを生成し、外部から直接インスタンス化を行うことができないようにしています。

class SingletonClass {
    private static instance: SingletonClass;

    // コンストラクタをプライベートにして外部からのインスタンス化を防止
    private constructor() {}

    // インスタンス取得メソッド
    public static getInstance(): SingletonClass {
        if (!this.instance) {
            this.instance = new SingletonClass();
        }
        return this.instance;
    }
}

// 正しいインスタンスの取得方法
const singleton = SingletonClass.getInstance();

// エラー: 'SingletonClass' のコンストラクタはプライベートであり、クラス宣言内でのみアクセスできます。
// const newInstance = new SingletonClass();

上記のサンプルコードでは、SingletonClassというクラスが定義されています。

その中にプライベートコンストラクタとgetInstanceという静的メソッドが定義されています。

このgetInstanceメソッドを使用して、インスタンスを取得します。

外部からnew SingletonClass()のようにインスタンスを生成しようとすると、コンストラクタがプライベートであるためエラーとなります。

そのため、このクラスのインスタンスは、getInstanceメソッドを通じてのみ取得可能です。

この方法によって、外部からのインスタンス化を完全に防ぐことができ、安全にシングルトンパターンを実現することができます。

もし、このシングルトンクラスに何らかの初期設定やカスタマイズを加えたい場合は、getInstanceメソッド内で条件分岐や追加の設定を行うことで、柔軟に対応することができます。

例えば、次のように初期設定を持つシングルトンを作成することも可能です。

class CustomizedSingleton {
    private static instance: CustomizedSingleton;
    public settingValue: string;

    private constructor(value: string) {
        this.settingValue = value;
    }

    public static getInstance(value: string = "default"): CustomizedSingleton {
        if (!this.instance) {
            this.instance = new CustomizedSingleton(value);
        }
        return this.instance;
    }
}

const customizedSingleton = CustomizedSingleton.getInstance("customValue");
console.log(customizedSingleton.settingValue);  // "customValue" と表示されます

上記の例では、CustomizedSingletonクラスが追加の設定値settingValueを持つようになっています。

getInstanceメソッドを呼び出す際に、この設定値を指定することができます。

○サンプルコード7:シングルトンの継承

TypeScriptにおけるシングルトンパターンの実装において、継承を使用した場合の特性とその実装方法を取り上げます。

継承を利用したシングルトンは、基本的なシングルトンの実装に継承の概念を加えることで、拡張性と再利用性を高めることができます。

このコードではTypeScriptを用いて、シングルトンの基本的な構造を継承する子クラスを作成する方法を表しています。

この例では、基本的なシングルトンの実装を親クラスとして定義し、それを継承する子クラスを作成しています。

// 基本的なシングルトンの実装を持つ親クラス
class SingletonParent {
    private static instance: SingletonParent;

    // コンストラクタをprotectedにすることで、外部からの直接のインスタンス生成を禁止
    protected constructor() {}

    public static getInstance(): SingletonParent {
        if (!this.instance) {
            this.instance = new SingletonParent();
        }
        return this.instance;
    }
}

// SingletonParentを継承した子クラス
class SingletonChild extends SingletonParent {
    public childMethod(): void {
        console.log("子クラスのメソッドが実行されました。");
    }
}

const childInstance = SingletonChild.getInstance();
childInstance.childMethod();

このサンプルコードを実際に実行すると、子クラスのメソッドが実行されました。というメッセージが出力されます。

SingletonChildクラスはSingletonParentクラスのシングルトンの特性を継承しているため、SingletonChildからもシングルトンのインスタンスを取得することができます。

しかし、継承を利用したシングルトンには注意が必要です。

親クラスと子クラスでシングルトンのインスタンスが異なる場合や、複数の子クラス間でインスタンスが共有されるという状況を避けるために、継承の際にはシングルトンの実装を適切にオーバーライドする必要があります。

また、シングルトンの継承時に独自のシングルトンの実装を持つ子クラスを作成する場合、次のように子クラスでシングルトンの実装をオーバーライドすることで対応可能です。

class SingletonChildOverride extends SingletonParent {
    private static childInstance: SingletonChildOverride;

    private constructor() {
        super();
    }

    public static getInstance(): SingletonChildOverride {
        if (!this.childInstance) {
            this.childInstance = new SingletonChildOverride();
        }
        return this.childInstance;
    }

    public childMethodOverride(): void {
        console.log("オーバーライドした子クラスのメソッドが実行されました。");
    }
}

const childOverrideInstance = SingletonChildOverride.getInstance();
childOverrideInstance.childMethodOverride();

このサンプルコードを実行すると、オーバーライドした子クラスのメソッドが実行されました。というメッセージが出力されます。

これにより、親クラスと子クラスのシングルトンのインスタンスを完全に分離することができ、予期しない動作を避けることができます。

○サンプルコード8:名前空間を利用したシングルトンの実装

TypeScriptにおいて、名前空間は関連するクラスや関数を1つのスコープ内にまとめる手段として提供されています。

名前空間を使用することで、グローバルスコープの汚染を防ぐことができます。

ここでは、名前空間を利用してシングルトンの実装を行う方法について紹介します。

このコードでは、名前空間「SingletonNamespace」内にシングルトンクラス「Singleton」を定義しています。

この例では、名前空間を使用してシングルトンクラスをグローバルスコープから隔離し、一意のインスタンスを生成しています。

namespace SingletonNamespace {
    export class Singleton {
        private static instance: Singleton;

        // コンストラクタはprivateとして定義
        private constructor() {}

        // インスタンスの取得方法
        public static getInstance(): Singleton {
            if (!this.instance) {
                this.instance = new Singleton();
            }
            return this.instance;
        }
    }
}

// インスタンスの生成方法
const singletonInstance = SingletonNamespace.Singleton.getInstance();

上記のコードを実行することで、名前空間「SingletonNamespace」内に定義されたシングルトンクラス「Singleton」のインスタンスを取得することができます。

名前空間を利用することで、他のコードとの名前衝突を回避しつつ、シングルトンパターンを実装することができます。

応用例として、名前空間内には関連する複数のクラスや関数をまとめることができます。

たとえば、データベース接続やAPIのクライアントなど、アプリケーション全体で共有すべきリソースに関する処理を、シングルトンとして名前空間内にまとめることが考えられます。

namespace DatabaseNamespace {
    export class DatabaseConnection {
        private static instance: DatabaseConnection;

        private constructor() {
            // DBへの接続処理など
        }

        public static getInstance(): DatabaseConnection {
            if (!this.instance) {
                this.instance = new DatabaseConnection();
            }
            return this.instance;
        }

        public query(sql: string) {
            // SQLクエリの実行
        }
    }
}

const db = DatabaseNamespace.DatabaseConnection.getInstance();
db.query("SELECT * FROM users");

この例では、「DatabaseNamespace」という名前空間内に「DatabaseConnection」というシングルトンクラスを定義し、データベースへの接続やクエリの実行といった処理を行っています。

名前空間を利用することで、関連するクラスや関数を一元的に管理することができ、コードの可読性や保守性を向上させることができます。

名前空間を使用したシングルトンの実装は、特に大規模なアプリケーションやライブラリの開発において、コードの構造を整理しやすくするメリットがあります。

ただし、小規模なアプリケーションにおいては、名前空間を使用する必要は必ずしもないため、適切な場面での利用を心がけるとよいでしょう。

○サンプルコード9:シングルトンの適切な破棄方法

シングルトンパターンを使用する際、一番の問題点として挙げられるのが、シングルトンのインスタンスがアプリケーションのライフサイクル全体で生存することです。

この特性は、特定のリソース(例えば、データベース接続やソケット)に対して継続的にアクセスする場面で有用ですが、そのリソースをもう使用しない場合、シングルトンのインスタンスを適切に破棄する必要があります。

このコードでは、TypeScriptでシングルトンの適切な破棄方法を実装するコードを表しています。

この例では、シングルトンインスタンスを作成し、それを適切に破棄しています。

class Singleton {
    private static instance: Singleton | null = null;

    private constructor() {}

    public static getInstance(): Singleton {
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }

    public static destroyInstance(): void {
        this.instance = null;
    }
}

const singletonInstance = Singleton.getInstance(); // シングルトンのインスタンスを取得
console.log(singletonInstance);

Singleton.destroyInstance(); // シングルトンのインスタンスを破棄
console.log(Singleton.getInstance());

上記のサンプルコードでは、SingletonクラスにdestroyInstanceメソッドを追加しています。

このメソッドは、シングルトンのインスタンスを破棄する役割を持ちます。

シングルトンのインスタンスが不要になった場合、このメソッドを呼び出すことで、インスタンスを破棄し、リソースを解放することができます。

上記のコードを実行すると、初めてSingleton.getInstance()を呼び出すと、新しいシングルトンのインスタンスが作成され、コンソールにそのインスタンスが出力されます。

その後、Singleton.destroyInstance()を呼び出すことで、シングルトンのインスタンスは破棄されます。

そして、再びSingleton.getInstance()を呼び出すと、新しいインスタンスが作成されて出力されることが確認できます。

この方法で、アプリケーションの特定のタイミングや状況でシングルトンのインスタンスを適切に破棄することができるようになります。

ただし、シングルトンのインスタンスを破棄する場面やタイミングは、アプリケーションの要件やシナリオに応じて適切に選択する必要があります。

無闇に破棄してしまうと、後からそのインスタンスが必要になった場合に再度生成するコストがかかるため、適切なタイミングでの破棄が必要です。

○サンプルコード10:依存関係注入とシングルトン

近年、依存関係注入(DI: Dependency Injection)は、アプリケーションの設計パターンの中でも特に注目を集めています。

TypeScriptにおけるシングルトンの実装と組み合わせることで、さらに強固なコードを書くことができます。

このコードでは、依存関係注入の原則を用いて、TypeScriptでのシングルトンパターンの実装方法を表しています。

この例では、シングルトンをDIコンテナを利用して管理し、オブジェクトのライフサイクルをコントロールしています。

// DIコンテナの実装
class DIContainer {
    private services: { [key: string]: any } = {};

    // サービスを登録するメソッド
    register(name: string, instance: any): void {
        this.services[name] = instance;
    }

    // サービスを取得するメソッド
    get(name: string): any {
        return this.services[name];
    }
}

// シングルトンクラスの実装
class Singleton {
    private static instance: Singleton;

    // プライベートコンストラクタ
    private constructor() {}

    // インスタンスを取得する静的メソッド
    static getInstance(): Singleton {
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }
}

// DIコンテナを使ってシングルトンを管理
const container = new DIContainer();
container.register("singleton", Singleton.getInstance());

// 使用例
const singletonFromContainer = container.get("singleton");
console.log(singletonFromContainer === Singleton.getInstance()); // true

上記のコードを見ると、DIContainerクラスがDIのコンテナとして機能しています。

このコンテナには、registerメソッドでサービスを登録し、getメソッドで登録されたサービスを取得することができます。

また、Singletonクラスは以前と同じシングルトンのパターンを実装していますが、DIContainerを利用することで、このシングルトンのインスタンスを容易に管理・取得することができます。

この例を実行すると、DIコンテナから取得したシングルトンのインスタンスと、直接Singleton.getInstance()で取得したインスタンスが同一であることが、出力結果からも確認できます。

依存関係注入を組み合わせることで、シングルトンの管理がさらに柔軟になります。

特に大規模なアプリケーション開発においては、このような方法を検討する価値があります。

しかし、この実装方法にもいくつかの注意点があります。

一つは、DIコンテナが大きくなりすぎると、管理が難しくなる点です。また、シングルトンのインスタンスが多くなりすぎると、メモリの効率的な使用やパフォーマンスに悪影響を及ぼす可能性も考慮する必要があります。

依存関係注入を使用する際のヒントとして、必要なサービスだけをDIコンテナに登録し、不要なサービスは削除することで、管理をシンプルに保つことがおすすめです。

●注意点と対処法

TypeScriptでシングルトンパターンを使用する際の注意点と、それらの問題を回避・対処する方法を紹介します。

○シングルトンの過度な使用

シングルトンパターンは便利ですが、適切でない場面や頻度で使用すると、ソフトウェア設計の問題を引き起こすことがあります。

たとえば、多くの場面でシングルトンを使用することは、緩い結合を失わせ、モジュール間の依存が増えてしまう可能性があります。

このコードでは、シングルトンのインスタンスが多くの箇所で使用される例を表しています。

この例では、シングルトンを過度に利用しているため、変更や拡張が難しくなっています。

class Singleton {
    private static instance: Singleton;
    private data: number = 0;

    private constructor() {}

    public static getInstance(): Singleton {
        if (!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }

    setData(d: number) {
        this.data = d;
    }

    getData() {
        return this.data;
    }
}

class A {
    doSomething() {
        const singleton = Singleton.getInstance();
        console.log(singleton.getData());
    }
}

class B {
    doAnotherThing() {
        const singleton = Singleton.getInstance();
        singleton.setData(5);
    }
}

この例での実行結果は、BクラスのdoAnotherThingメソッドを実行した後に、AクラスのdoSomethingメソッドを実行すると、5が出力されます。

これは、両方のクラスが同じシングルトンのインスタンスにアクセスしているためです。

○シングルトンとテスト

シングルトンパターンはテストが難しくなるという問題があります。

シングルトンのインスタンスはアプリケーション全体で共有されるため、一つのテストで状態を変更すると、他のテストに影響を与える可能性があります。

テストを簡単にするための方法として、シングルトンのリセット機能を追加することが考えられます。

ただし、この方法はシングルトンの主な目的である「唯一のインスタンス」を損なう可能性があるため、注意が必要です。

○シングルトンとメモリ管理

シングルトンはアプリケーションの生涯中、メモリ上に存在し続けるため、リソースの消費が懸念される場面もあります。

大量のデータや重たいリソースを保持するシングルトンは、メモリの無駄遣いとなることがあります。

シングルトンのメモリ消費を適切に管理する方法として、使用しなくなったリソースの適切な破棄や、遅延初期化を使用して必要なときにのみインスタンスを生成するなどのテクニックが考えられます。

●カスタマイズ方法

TypeScriptのシングルトンパターンは非常に強力で、多くの場面で役立ちますが、特定のプロジェクトニーズに合わせてカスタマイズすることが求められることもあります。

それでは、シングルトンパターンのカスタマイズのための主要な手法を紹介します。

○シングルトンの拡張方法

シングルトンパターンは、基本的な実装の上で機能や振る舞いを追加することができます。

例えば、シングルトンのインスタンス生成時にログを取るなどの拡張が考えられます。

このコードでは、シングルトンのインスタンスが生成された時刻をログとして取得するコードを表しています。

この例では、getInstanceメソッドが呼び出されるたびに、ログが追加されます。

class LoggerSingleton {
    private static instance: LoggerSingleton;
    private logs: string[] = [];

    private constructor() {}

    public static getInstance(): LoggerSingleton {
        if (!LoggerSingleton.instance) {
            LoggerSingleton.instance = new LoggerSingleton();
            LoggerSingleton.instance.addLog('シングルトンがインスタンス化されました。');
        }
        return LoggerSingleton.instance;
    }

    addLog(log: string) {
        const timestamp = new Date().toISOString();
        this.logs.push(`${timestamp}: ${log}`);
    }

    showLogs() {
        return this.logs;
    }
}

const logger = LoggerSingleton.getInstance();
logger.addLog("新しいログを追加");
console.log(logger.showLogs());

上記のコードを実行すると、シングルトンの生成時刻と、「新しいログを追加」というログが出力されることになります。

これにより、シングルトンの動作を簡単に追跡することができます。

○シングルトンの代替案

シングルトンパターンは非常に便利ですが、全ての場面で最適なわけではありません。

特定の状況では、他のパターンを検討することも考えられます。

  1. ファクトリーメソッド:インスタンス生成の過程を隠蔽しながら、柔軟なオブジェクト生成を可能にします。
  2. プロトタイプ:既存のオブジェクトをコピーして新しいオブジェクトを生成するという方法です。大量のインスタンスを迅速に作成する際に効果的です。

これらの代替案を適切に使用することで、シングルトンの制約を乗り越え、さらに柔軟な設計を追求することができます。

まとめ

TypeScriptでのシングルトンパターンは、アプリケーションのあらゆる部分で一貫したオブジェクトのアクセスを保証するための有力な手段です。

しかし、ニーズに応じてカスタマイズや代替手段を検討することで、より適切な設計を追求することができます。

この記事を通じて、読者の皆様がTypeScriptのシングルトンパターンをより深く理解し、実際のプロジェクトに適切に応用していただけることを期待しています。