Classes statiques TypeScript

Question

Je voulais passer de JS traditionnel à TypeScript parce que j'aime la syntaxe proche de C#. Mon problème est que je n'arrive pas à trouver comment déclarer des classes statiques en TypeScript.

En C#, j'utilise souvent les classes statiques pour organiser les variables et les méthodes, en les regroupant dans une classe nommée, sans avoir besoin d'instancier un objet. En vanilla JS, j'avais l'habitude de faire cela avec un simple objet JS :

var myStaticClass = {
    property: 10,
    method: function(){}
}

En TypeScript, j'opterais plutôt pour mon approche C-sharpy, mais il semble que les classes statiques n'existent pas en TS. Quelle est la solution appropriée à ce problème ?

Answer 1

Les classes abstraites sont des citoyens de première classe de TypeScript depuis TypeScript 1.6. Vous ne pouvez pas instancier une classe abstraite.

Voici un exemple :

export abstract class MyClass {         
    public static myProp = "Hello";

    public static doSomething(): string {
      return "World";
    }
}

const okay = MyClass.doSomething();

//const errors = new MyClass(); // Error

Answer 2

TypeScript n'est pas C#, donc vous ne devez pas nécessairement vous attendre à retrouver les mêmes concepts de C# dans TypeScript. La question est de savoir pourquoi vous voulez des classes statiques ?

En C#, une classe statique est simplement une classe qui ne peut pas être sous-classée et qui ne doit contenir que des méthodes statiques. Le C# ne permet pas de définir des fonctions en dehors des classes. En TypeScript, cela est toutefois possible.

Si vous cherchez un moyen de placer vos fonctions/méthodes dans un espace de nom (c'est-à-dire non global), vous pouvez envisager d'utiliser les modules de TypeScript, par exemple.

module M {
    var s = "hello";
    export function f() {
        return s;
    }
}

Ainsi, vous pouvez accéder à M.f() en externe, mais pas à s, et vous ne pouvez pas étendre le module.

Voir la page TypeScript spécification pour plus de détails.

Answer 3

La définition des propriétés statiques et des méthodes d'une classe est décrite dans la section 8.2.1 de la norme Spécification du langage Typescript :

class Point { 
  constructor(public x: number, public y: number) { 
    throw new Error('cannot instantiate using a static class');
  } 
  public distance(p: Point) { 
    var dx = this.x - p.x; 
    var dy = this.y - p.y; 
    return Math.sqrt(dx * dx + dy * dy); 
  } 
  static origin = new Point(0, 0); 
  static distance(p1: Point, p2: Point) { 
    return p1.distance(p2); 
  } 
}

donde Point.distance() est une méthode statique (ou "de classe").

UPDATE : Le lien ci-dessus a été mis à jour avec la version la plus récente de la spécification Typescript, mais veuillez noter que par https://github.com/Microsoft/TypeScript/issues/15711 Il n'existe actuellement aucune spécification faisant autorité pour Typescript, et il n'est pas prévu qu'il y en ait une.

Answer 4

Cette question date un peu, mais je voulais laisser une réponse qui tire parti de la version actuelle du langage. Malheureusement, les classes statiques n'existent toujours pas en TypeScript, mais vous pouvez écrire une classe qui se comporte de manière similaire avec seulement une petite surcharge en utilisant un constructeur privé qui empêche l'instanciation des classes de l'extérieur.

class MyStaticClass {
    public static readonly property: number = 42;
    public static myMethod(): void { /* ... */ }
    private constructor() { /* noop */ }
}

Cet extrait vous permettra d'utiliser des classes "statiques" similaires à celles du C#, avec le seul inconvénient qu'il est toujours possible de les instancier de l'intérieur. Heureusement, vous ne pouvez pas étendre les classes avec des constructeurs privés.

Answer 5

C'est une façon de faire :

class SomeClass {
    private static myStaticVariable = "whatever";
    private static __static_ctor = (() => { /* do static constructor stuff :) */ })();
}

__static_ctor voici une expression de fonction immédiatement invoquée. Typescript produira du code pour l'appeler à la fin de la classe générée.

Mise à jour : Pour les types génériques dans les constructeurs statiques, qui ne sont plus autorisés à être référencés par des membres statiques, vous aurez besoin d'une étape supplémentaire maintenant :

class SomeClass<T> {
    static myStaticVariable = "whatever";
    private ___static_ctor = (() => { var someClass:SomeClass<T> ; /* do static constructor stuff :) */ })();
    private static __static_ctor = SomeClass.prototype.___static_ctor();
}

Dans tous les cas, bien sûr, vous pourriez simplement appeler le constructeur statique du type générique après la classe, comme par exemple :

class SomeClass<T> {
    static myStaticVariable = "whatever";
    private __static_ctor = (() => { var example: SomeClass<T>; /* do static constructor stuff :) */ })();
}
SomeClass.prototype.__static_ctor();

N'oubliez pas de ne JAMAIS utiliser this en __static_ctor ci-dessus (évidemment).