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

J'ai eu le même cas d'utilisation aujourd'hui(31/07/2018) et j'ai trouvé ceci pour être une solution de contournement. Elle est basée sur mes recherches et a fonctionné pour moi. Attente - Pour réaliser ce qui suit en TypeScript :

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

J'ai fait ça :

//MyStaticMembers.ts
namespace MyStaticMembers {
        class MyStaticClass {
           static property: number = 10;
           static myMethod() {...}
        }
        export function Property(): number {
           return MyStaticClass.property;
        }
        export function Method(): void {
           return MyStaticClass.myMethod();
        }
     }

Nous allons donc le consommer comme suit :

//app.ts
/// <reference path="MyStaticMembers.ts" />
    console.log(MyStaticMembers.Property);
    MyStaticMembers.Method();

Cela a marché pour moi. Si quelqu'un a d'autres meilleures suggestions, faites-les nous connaître ! !! Merci...

Answer 2

Les classes statiques dans des langages comme C# existent parce qu'il n'y a pas d'autres constructions de haut niveau pour regrouper les données et les fonctions. En JavaScript, par contre, elles existent et il est donc beaucoup plus naturel de déclarer un objet comme vous l'avez fait. Pour imiter plus fidèlement la syntaxe des classes, vous pouvez déclarer des méthodes comme suit :

const myStaticClass = {
    property: 10,

    method() {

    }
}

Answer 3

Avec les modules externes ES6, cela peut être réalisé comme suit :

// privately scoped array
let arr = [];

export let ArrayModule = {
    add: x => arr.push(x),
    print: () => console.log(arr),
}

Cela empêche l'utilisation de modules internes et d'espaces de noms, ce qui est considéré comme une mauvaise pratique par TSLint. [1] [2] permet de définir le champ d'application privé et public et empêche l'initialisation d'objets de classe indésirables.

Answer 4

Ver http://www.basarat.com/2013/04/typescript-static-constructors-for.html

C'est une façon de "simuler" un constructeur statique. Ce n'est pas sans danger - voir l'exemple du article de codeplex référencé .

class Test {
    static foo = "orig";

    // Non void static function
    static stat() {
        console.log("Do any static construction here");
        foo = "static initialized";
        // Required to make function non void
        return null;
    }
    // Static variable assignment
    static statrun = Test.stat();
}

// Static construction will have been done:
console.log(Test.foo);

Answer 5

Une façon possible d'y parvenir est d'avoir des instances statiques d'une classe à l'intérieur d'une autre classe. Par exemple :

class SystemParams
{
  pageWidth:  number = 8270;
  pageHeight: number = 11690;  
}

class DocLevelParams
{
  totalPages: number = 0;
}

class Wrapper
{ 
  static System: SystemParams = new SystemParams();
  static DocLevel: DocLevelParams = new DocLevelParams();
}

On peut alors accéder aux paramètres en utilisant Wrapper, sans avoir à déclarer une instance de celui-ci. Par exemple :

Wrapper.System.pageWidth = 1234;
Wrapper.DocLevel.totalPages = 10;

Vous bénéficiez donc des avantages de l'objet de type JavaScript (comme décrit dans la question initiale), mais aussi de la possibilité d'ajouter le typage TypeScript. En outre, cela évite de devoir ajouter "static" devant tous les paramètres de la classe.