Come definire Singleton in TypeScript

Qual è il modo migliore e più conveniente per implementare un modello Singleton per una classe in TypeScript? (Sia con che senza inizializzazione pigra).

Le classi Singleton in TypeScript sono generalmente un anti-pattern. Puoi semplicemente usare gli spazi dei nomi invece.

Modello singleton inutile

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

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

Equivalente nello spazio dei nomi

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

Da TS 2.0, abbiamo la possibilità di definire modificatori di visibilità sui costruttori , quindi ora possiamo creare singleton in TypeScript proprio come siamo abituati da altri linguaggi.

Esempio dato:

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;

Grazie @Drenai per aver sottolineato che se scrivi il codice utilizzando il javascript compilato non avrai protezione contro l'istanza multipla, poiché i vincoli di TS scompaiono e il costruttore non sarà nascosto.

Il modo migliore che ho trovato è:

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;
    }

}

Ecco come lo usi:

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/

Il seguente approccio crea una classe Singleton che può essere utilizzata esattamente come una classe convenzionale:

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;
}

Ogni new Singleton()operazione restituirà la stessa istanza. Ciò può tuttavia essere inatteso dall'utente.

L'esempio seguente è più trasparente per l'utente ma richiede un uso diverso:

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;
}

Uso: var obj = Singleton.getInstance();

Sono sorpreso di non vedere il seguente schema qui, che in realtà sembra molto semplice.

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

export let Shout = new ShoutSingleton();

uso

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

Puoi usare espressioni di classe per questo (a partire dalla 1.6 credo).

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

o con il nome se la tua classe deve accedere al suo tipo internamente

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

Un'altra opzione è quella di utilizzare una classe locale all'interno del singleton usando alcuni membri statici

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();

Aggiungi le seguenti 6 righe a qualsiasi classe per renderlo "Singleton".

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

Esempio di test:

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

[Modifica]: usa la risposta Alex se preferisci ottenere l'istanza attraverso una proprietà piuttosto che un metodo.

penso che forse usare i generici sia una pastella

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;
}

come usare

passo 1

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

passo 2

    MapManager.Instance(MapManager).init();

È inoltre possibile utilizzare la funzione Object.Freeze () . È semplice e facile:

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;

Ho trovato una nuova versione di questo con cui il compilatore Typescript è totalmente a posto, e penso che sia meglio perché non richiede di chiamare un getInstance()metodo costantemente.

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;
  }
}

Ciò comporta uno svantaggio diverso. Se Singletonhai delle proprietà, allora il compilatore Typescript lancerà un adattamento a meno che tu non li inizializzi con un valore. Ecco perché ho incluso una _expressproprietà nella mia classe di esempio perché, a meno che non venga inizializzata con un valore, anche se la si assegna successivamente nel costruttore, Typescript penserà che non sia stata definita. Questo potrebbe essere risolto disabilitando la modalità rigorosa, ma preferisco non farlo se possibile. C'è anche un altro aspetto negativo di questo metodo che dovrei sottolineare, poiché il costruttore viene effettivamente chiamato, ogni volta che fa un'altra istanza viene tecnicamente creata, ma non accessibile. Ciò potrebbe, in teoria, causare perdite di memoria.

Questo è probabilmente il processo più lungo per creare un singleton in dattiloscritto, ma in applicazioni più grandi è quello che ha funzionato meglio per me.

Per prima cosa hai bisogno di una classe Singleton in, diciamo, "./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; }
    }
}

Ora immagina di aver bisogno di un singleton del router "./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();
}

Nice !, ora inizializzare o importare ovunque sia necessario:

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

import router = navigation.Router;

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

La cosa bella di fare i singleton in questo modo è che usi ancora tutta la bellezza delle classi dattiloscritte, ti dà un buon intellisense, la logica singleton rimane in qualche modo separata ed è facile da rimuovere se necessario.

La mia soluzione per questo:

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;
    }
}

In Typescript, non si deve necessariamente seguire la new instance()metodologia Singleton. Anche una classe statica importata senza costruttore può funzionare allo stesso modo.

Tener conto di:

export class YourSingleton {

   public static foo:bar;

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

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

È possibile importare la classe e fare riferimento YourSingleton.doThing()in qualsiasi altra classe. Ma ricorda, poiché questa è una classe statica, non ha un costruttore, quindi di solito uso un intialise()metodo chiamato da una classe che importa Singleton:

import {YourSingleton} from 'singleton.ts';

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

Non dimenticare che in una classe statica, ogni metodo e variabile deve anche essere statico, quindi invece di thisutilizzare il nome completo della classe YourSingleton.

Ecco un altro modo per farlo con un approccio javascript più convenzionale usando un 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();

Guarda una demo

Un'altra opzione è utilizzare i simboli nel modulo. In questo modo puoi proteggere la tua classe, anche se l'utente finale della tua API sta usando il normale 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";
    }
}

Uso:

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

Se l'utente sta utilizzando il file js API compilato, inoltre riceverà un errore se tenta di creare un'istanza manualmente la classe:

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

Non un singolo singleton (l'inizializzazione può non essere pigra), ma un modello simile con l'aiuto di namespaces.

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

Accesso all'oggetto di Singleton:

MyClass.instance

Questo è il modo più semplice

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();
}

In questo modo possiamo applicare un'interfaccia, diversamente dalla risposta accettata da Ryan Cavanaugh.

Dopo aver setacciato questo thread e aver giocato con tutte le opzioni sopra, ho optato per un Singleton che può essere creato con costruttori appropriati:

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 */ }

}

Richiederebbe una configurazione iniziale (in main.ts, o index.ts), che può essere facilmente implementata da
new Singleton(/* PARAMS */)

Quindi, ovunque nel tuo codice, basta chiamare Singleton.instnace; in questo caso, per workfare ciò, chiamereiSingleton.instance.work()