Classes statiques TypeScript

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

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

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

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

Pour que vous puissiez accéder à Mf () à l'extérieur, mais pas s, et vous ne pouvez pas étendre le module.

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

La définition des propriétés statiques et des méthodes d'une classe est décrite dans 8.2.1 de la spécification de langue de type :

 class Point { constructor(public x: number, public y: number) { } public distance(p: Point) { var dx = this.x - px; var dy = this.y - py; return Math.sqrt(dx * dx + dy * dy); } static origin = new Point(0, 0); static distance(p1: Point, p2: Point) { return p1.distance(p2); } } 

Où Point.distance () est une méthode statique (ou "classe").

Pour créer une classe statique dans TypeScript, vous pouvez marquer toutes les propriétés et toutes les méthodes comme étant statiques, certaines personnes ont mentionné, mais en plus, vous pouvez également vous assurer que de nouvelles instances de la classe lancent une exception pour empêcher les instances créées. Cela oblige essentiellement la classe à ne pas être utilisée de manière statique, même si l'erreur est l'exécution, pas le temps de compilation.

 module ExampleModule { export class MyClass { constructor() { throw new Error("Cannot new this class"); } static myProp = "Hello"; static doSomething() { return "World"; } } } var x = ExampleModule.MyClass.doSomething(); //var example = new ExampleModule.MyClass(); // Error alert(x); 

Si vous vouliez des avertissements de temps de compilation, vous pouvez créer une interface IErrorOnNew pour passer dans le constructeur, ce qui vous rappelle qu'il ne doit pas être construit. C'est un peu sur le dessus vraiment, mais cela vous rappelle le temps de compilation.

 constructor(x: IErrorOnNew) { throw new Error("Cannot new this class"); } 

C'est une façon:

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

__static_ctor ici est une expression de fonction appelée immédiatement. Le dictionnaire typographique va générer un 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.___ctor(); } 

Dans tous les cas, bien sûr, vous pouvez simplement appeler le constructeur statique de type générique après la classe, tel que:

 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 l'utiliser dans __static_ctor ci-dessus (évidemment).

Je cherchais quelque chose de semblable et je me trouvais à travers quelque chose appelé Singleton Pattern .

Référence: Singleton Pattern

Je travaille sur une classe BulkLoader pour charger différents types de fichiers et je voulais utiliser le modèle Singleton pour cela. De cette façon, je peux charger des fichiers de ma classe d'application principale et récupérer facilement les fichiers chargés à partir d'autres classes.

Voici un exemple simple de la façon dont vous pouvez faire un gestionnaire de score pour un jeu avec TypeScript et le modèle Singleton.

Classe SingletonClass {

 private static _instance:SingletonClass = new SingletonClass(); private _score:number = 0; constructor() { if(SingletonClass._instance){ throw new Error("Error: Instantiation failed: Use SingletonDemo.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; } } 

Ensuite, n'importe où dans vos autres classes, vous obtiendrez l'accès au Singleton en:

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

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

C'est un moyen de «faux» un constructeur statique. Ce n'est pas sans danger: voir l' article 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); 

Il existe des classes statiques dans des langages comme C # car il n'y a pas d'autres constructions de niveau supérieur pour regrouper les données et les fonctions. En JavaScript, cependant, ils le font et il est donc beaucoup plus naturel de déclarer un objet comme vous. Pour imiter de plus près la syntaxe de la classe, vous pouvez déclarer des méthodes comme ceci:

 const myStaticClass = { property: 10, method() { } }