Jak zdefiniować Singleton w TypeScript

Jaki jest najlepszy i najwygodniejszy sposób implementacji wzorca Singleton dla klasy w języku TypeScript? (Zarówno z leniwą inicjalizacją, jak i bez niej).

Klasy singleton w TypeScript są generalnie anty-wzorcem. Zamiast tego możesz po prostu użyć przestrzeni nazw .

Bezużyteczny wzór singletona

class Singleton {
    /* ... lots of singleton logic ... */
    public someMethod() { ... }
}

// Using
var x = Singleton.getInstance();
x.someMethod();

Odpowiednik przestrzeni nazw

export namespace Singleton {
    export function someMethod() { ... }
}
// Usage
import { SingletonInstance } from "path/to/Singleton";

SingletonInstance.someMethod();
var x = SingletonInstance; // If you need to alias it for some reason

Od TS 2.0 mamy możliwość definiowania modyfikatorów widoczności w konstruktorach , więc teraz możemy tworzyć pojedyncze elementy w TypeScript, tak jak jesteśmy przyzwyczajeni z innych języków.

Podany przykład:

class MyClass
{
    private static _instance: MyClass;

    private constructor()
    {
        //...
    }

    public static get Instance()
    {
        // Do you need arguments? Make it a regular static method instead.
        return this._instance || (this._instance = new this());
    }
}

const myClassInstance = MyClass.Instance;

Dziękuję @Drenai za wskazanie, że jeśli piszesz kod przy użyciu skompilowanego surowego javascript, nie będziesz mieć ochrony przed wielokrotnymi instancjami, ponieważ ograniczenia TS znikną, a konstruktor nie zostanie ukryty.

Najlepszy sposób, jaki znalazłem, to:

class SingletonClass {

    private static _instance:SingletonClass = new SingletonClass();

    private _score:number = 0;

    constructor() {
        if(SingletonClass._instance){
            throw new Error("Error: Instantiation failed: Use SingletonClass.getInstance() instead of new.");
        }
        SingletonClass._instance = this;
    }

    public static getInstance():SingletonClass
    {
        return SingletonClass._instance;
    }

    public setScore(value:number):void
    {
        this._score = value;
    }

    public getScore():number
    {
        return this._score;
    }

    public addPoints(value:number):void
    {
        this._score += value;
    }

    public removePoints(value:number):void
    {
        this._score -= value;
    }

}

Oto jak go używasz:

var scoreManager = SingletonClass.getInstance();
scoreManager.setScore(10);
scoreManager.addPoints(1);
scoreManager.removePoints(2);
console.log( scoreManager.getScore() );

https://codebelt.github.io/blog/typescript/typescript-singleton-pattern/

Poniższe podejście tworzy klasę Singleton, której można używać dokładnie tak, jak klasycznej klasy:

class Singleton {
    private static instance: Singleton;
    //Assign "new Singleton()" here to avoid lazy initialisation

    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }

        this. member = 0;
        Singleton.instance = this;
    }

    member: number;
}

Każdy new Singleton() operacja zwróci to samo wystąpienie. Może to być jednak nieoczekiwane przez użytkownika.

Poniższy przykład jest bardziej przejrzysty dla użytkownika, ale wymaga innego zastosowania:

class Singleton {
    private static instance: Singleton;
    //Assign "new Singleton()" here to avoid lazy initialisation

    constructor() {
        if (Singleton.instance) {
            throw new Error("Error - use Singleton.getInstance()");
        }
        this.member = 0;
    }

    static getInstance(): Singleton {
        Singleton.instance = Singleton.instance || new Singleton();
        return Singleton.instance;
    }

    member: number;
}

Stosowanie: var obj = Singleton.getInstance();

Dziwię się, że nie widzę tutaj następującego wzoru, który w rzeczywistości wygląda bardzo prosto.

// shout.ts
class ShoutSingleton {
  helloWorld() { return 'hi'; }
}

export let Shout = new ShoutSingleton();

Stosowanie

import { Shout } from './shout';
Shout.helloWorld();

Możesz użyć do tego wyrażeń klasowych (od wersji 1.6, jak sądzę).

var x = new (class {
    /* ... lots of singleton logic ... */
    public someMethod() { ... }
})();

lub z nazwą, jeśli Twoja klasa potrzebuje wewnętrznego dostępu do jej typu

var x = new (class Singleton {
    /* ... lots of singleton logic ... */
    public someMethod(): Singleton { ... }
})();

Inną opcją jest użycie lokalnej klasy wewnątrz singletona przy użyciu statycznych elementów członkowskich

class Singleton {

    private static _instance;
    public static get instance() {

        class InternalSingleton {
            someMethod() { }

            //more singleton logic
        }

        if(!Singleton._instance) {
            Singleton._instance = new InternalSingleton();
        }

        return <InternalSingleton>Singleton._instance;
    }
}

var x = Singleton.instance;
x.someMethod();

Dodaj następujące 6 wierszy do dowolnej klasy, aby nadać jej nazwę „Singleton”.

class MySingleton
{
    private constructor(){ /* ... */}
    private static _instance: MySingleton;
    public static getInstance(): MySingleton
    {
        return this._instance || (this._instance = new this());
    };
}

Przykład testu:

var test = MySingleton.getInstance(); // will create the first instance
var test2 = MySingleton.getInstance(); // will return the first instance
alert(test === test2); // true

[Edytuj]: Użyj odpowiedzi Alexa, jeśli wolisz uzyskać instancję za pomocą właściwości, a nie metody.

Myślę, że może użyć leków generycznych

class Singleton<T>{
    public static Instance<T>(c: {new(): T; }) : T{
        if (this._instance == null){
            this._instance = new c();
        }
        return this._instance;
    }

    private static _instance = null;
}

jak używać

krok 1

class MapManager extends Singleton<MapManager>{
     //do something
     public init():void{ //do }
}

krok 2

    MapManager.Instance(MapManager).init();

Możesz także skorzystać z funkcji Object.Freeze () . To proste i łatwe:

class Singleton {

  instance: any = null;
  data: any = {} // store data in here

  constructor() {
    if (!this.instance) {
      this.instance = this;
    }
    return this.instance
  }
}

const singleton: Singleton = new Singleton();
Object.freeze(singleton);

export default singleton;

Znalazłem nową wersję tego, z którą kompilator Typescript jest całkowicie w porządku i myślę, że jest lepsza, ponieważ nie wymaga getInstance()ciągłego wywoływania metody.

import express, { Application } from 'express';

export class Singleton {
  // Define your props here
  private _express: Application = express();
  private static _instance: Singleton;

  constructor() {
    if (Singleton._instance) {
      return Singleton._instance;
    }

    // You don't have an instance, so continue

    // Remember, to set the _instance property
    Singleton._instance = this;
  }
}

Ma to inną wadę. Jeśli Singletonmasz jakieś właściwości, kompilator Typescript wykona dopasowanie, chyba że zainicjujesz je wartością. Dlatego dołączyłem _expresswłaściwość do mojej przykładowej klasy, ponieważ jeśli nie zainicjujesz jej wartością, nawet jeśli przypiszesz ją później w konstruktorze, Typescript pomyśli, że nie została zdefiniowana. Można to naprawić, wyłączając tryb ścisły, ale wolę tego nie robić, jeśli to możliwe. Jest jeszcze jedna wada tej metody, na którą powinienem zwrócić uwagę, ponieważ konstruktor jest faktycznie wywoływany, za każdym razem, gdy wykonuje inną instancję, jest technicznie tworzona, ale niedostępna. Może to teoretycznie powodować wycieki pamięci.

Jest to prawdopodobnie najdłuższy proces tworzenia singletona w maszynopisie, ale w większych aplikacjach jest to ten, który działał lepiej dla mnie.

Najpierw potrzebujesz klasy Singleton w, powiedzmy, „./utils/Singleton.ts” :

module utils {
    export class Singleton {
        private _initialized: boolean;

        private _setSingleton(): void {
            if (this._initialized) throw Error('Singleton is already initialized.');
            this._initialized = true;
        }

        get setSingleton() { return this._setSingleton; }
    }
}

Teraz wyobraź sobie, że potrzebujesz singletona routera „./navigation/Router.ts” :

/// <reference path="../utils/Singleton.ts" />

module navigation {
    class RouterClass extends utils.Singleton {
        // NOTICE RouterClass extends from utils.Singleton
        // and that it isn't exportable.

        private _init(): void {
            // This method will be your "construtor" now,
            // to avoid double initialization, don't forget
            // the parent class setSingleton method!.
            this.setSingleton();

            // Initialization stuff.
        }

        // Expose _init method.
        get init { return this.init; }
    }

    // THIS IS IT!! Export a new RouterClass, that no
    // one can instantiate ever again!.
    export var Router: RouterClass = new RouterClass();
}

Świetnie !, teraz zainicjuj lub zaimportuj, gdziekolwiek potrzebujesz:

/// <reference path="./navigation/Router.ts" />

import router = navigation.Router;

router.init();
router.init(); // Throws error!.

Zaletą robienia singletonów w ten sposób jest to, że nadal używasz całego piękna klas maszynopisu, daje to niezły intelizm, logika singletonów jest w jakiś sposób oddzielona i można ją łatwo usunąć w razie potrzeby.

Moje rozwiązanie:

export default class Modal {
    private static _instance : Modal = new Modal();

    constructor () {
        if (Modal._instance) 
            throw new Error("Use Modal.instance");
        Modal._instance = this;
    }

    static get instance () {
        return Modal._instance;
    }
}

W przypadku maszynopisu niekoniecznie trzeba przestrzegać new instance() metodologii Singleton. Zaimportowana klasa statyczna bez konstruktora może również działać równie dobrze.

Rozważać:

export class YourSingleton {

   public static foo:bar;

   public static initialise(_initVars:any):void {
     YourSingleton.foo = _initvars.foo;
   }

   public static doThing():bar {
     return YourSingleton.foo
   }
}

Możesz zaimportować klasę i odnosić się do niej YourSingleton.doThing()w dowolnej innej klasie. Ale pamiętaj, ponieważ jest to klasa statyczna, nie ma konstruktora, więc zazwyczaj używam intialise()metody, która jest wywoływana z klasy importującej Singleton:

import {YourSingleton} from 'singleton.ts';

YourSingleton.initialise(params);
let _result:bar = YourSingleton.doThing();

Nie zapominaj, że w klasie statycznej każda metoda i zmienna również musi być statyczna, więc zamiast thisciebie należy użyć pełnej nazwy klasy YourSingleton.

Oto kolejny sposób na zrobienie tego z bardziej konwencjonalnym podejściem javascript przy użyciu IFFE :

module App.Counter {
    export var Instance = (() => {
        var i = 0;
        return {
            increment: (): void => {
                i++;
            },
            getCount: (): number => {
                return i;
            }
        }
    })();
}

module App {
    export function countStuff() {
        App.Counter.Instance.increment();
        App.Counter.Instance.increment();
        alert(App.Counter.Instance.getCount());
    }
}

App.countStuff();

Zobacz demo

Inną opcją jest użycie symboli w module. W ten sposób możesz chronić swoją klasę, również jeśli końcowy użytkownik twojego API używa normalnego Javascript:

let _instance = Symbol();
export default class Singleton {

    constructor(singletonToken) {
        if (singletonToken !== _instance) {
            throw new Error("Cannot instantiate directly.");
        }
        //Init your class
    }

    static get instance() {
        return this[_instance] || (this[_instance] = new Singleton(_singleton))
    }

    public myMethod():string {
        return "foo";
    }
}

Stosowanie:

var str:string = Singleton.instance.myFoo();

Jeśli użytkownik używa Twojego skompilowanego pliku js API, również otrzyma błąd, jeśli spróbuje ręcznie utworzyć instancję Twojej klasy:

// PLAIN JAVASCRIPT: 
var instance = new Singleton(); //Error the argument singletonToken !== _instance symbol

Nie jest to czysty singleton (inicjalizacja może nie być leniwa), ale podobny wzór za pomocą namespaces.

namespace MyClass
{
    class _MyClass
    {
    ...
    }
    export const instance: _MyClass = new _MyClass();
}

Dostęp do obiektu Singleton:

MyClass.instance

To jest najprostszy sposób

class YourSingletoneClass {
  private static instance: YourSingletoneClass;

  private constructor(public ifYouHaveAnyParams: string) {

  }
  static getInstance() {
    if(!YourSingletoneClass.instance) {
      YourSingletoneClass.instance = new YourSingletoneClass('If you have any params');
    }
    return YourSingletoneClass.instance;
  }
}

namespace MySingleton {
  interface IMySingleton {
      doSomething(): void;
  }
  class MySingleton implements IMySingleton {
      private usePrivate() { }
      doSomething() {
          this.usePrivate();
      }
  }
  export var Instance: IMySingleton = new MySingleton();
}

W ten sposób możemy zastosować interfejs, w przeciwieństwie do zaakceptowanej odpowiedzi Ryana Cavanaugha.

Po przejrzeniu tego wątku i zabawie wszystkimi powyższymi opcjami - zdecydowałem się na Singletona, który można stworzyć za pomocą odpowiednich konstruktorów:

export default class Singleton {
  private static _instance: Singleton

  public static get instance(): Singleton {
    return Singleton._instance
  }

  constructor(...args: string[]) {
    // Initial setup

    Singleton._instance = this
  }

  work() { /* example */ }

}

Wymagałoby to wstępnej konfiguracji (w main.tslub index.ts), którą można łatwo zaimplementować za pomocą
new Singleton(/* PARAMS */)

Następnie, w dowolnym miejscu kodu, po prostu zadzwoń Singleton.instnace; w takim przypadku, żeby workskończyć, zadzwonięSingleton.instance.work()