Tapuscrit de classes statiques

Tapuscrit est pas en C#, donc ne vous attendez pas les mêmes concepts de C# en caractères d'imprimerie nécessairement. La question est: pourquoi voulez-vous les classes statiques?

En C# une classe statique est simplement une classe qui ne peut pas être sous-classé et ne doit contenir que des méthodes statiques. C# ne permet pas de définir des fonctions en dehors des classes. À la Machine, c'est possible, cependant.

Si vous êtes à la recherche d'un moyen de mettre vos fonctions/méthodes dans un espace de noms (c'est à dire pas global), vous pourriez envisager d'utiliser des caractères d'imprimerie de modules, par exemple

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

De sorte que vous pouvez accéder à M. f() de l'extérieur, mais pas de s, et vous ne pouvez pas étendre le module.

Voir le Tapuscrit spécification pour plus de détails.

La définition de propriétés et de méthodes statiques d'une classe est décrite dans 8.2.1 de la Tapuscrit Langage De Spécification:

class Point { 
  constructor(public x: number, public y: number) { } 
  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); 
  } 
}

où Point.distance() est statique (ou "classe"), méthode.

De cette manière:

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

__static_ctor ici est immédiatement appelée fonction d'expression. Tapuscrit sera de sortie code pour 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é par les 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 type générique constructeur statique après la classe, par exemple:

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

Rappelez-vous de ne JAMAIS utiliser this dans __static_ctor ci-dessus (évidemment).

Statique des classes dans les langages tels que C# existent pas car il n'y a pas d'autres haut-niveau de constructions pour des groupes de données et des fonctions. En JavaScript, cependant, qu'ils font et donc, il est beaucoup plus naturel de simplement déclarer un objet comme vous l'avez fait. Pour mieux imiter la classe de syntaxe, vous pouvez déclarer des méthodes comme:

const myStaticClass = {
    property: 10,

    method() {

    }
}

Un moyen possible d'y parvenir est d'avoir statique des instances d'une classe dans une autre. 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();
}

Puis paramètres peut être consulté à l'aide de Wrapper, sans avoir à déclarer une instance de celle-ci. Par exemple:

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

Vous obtiendrez les avantages de l'JavaScript type d'objet (comme décrit dans la question d'origine), mais avec les avantages d'être en mesure d'ajouter le fichier d'enregistrement de la frappe. En outre, il évite d'avoir à ajouter "statique" en face de tous les paramètres dans la classe.

Vous pouvez également utiliser le mot-clé namespace pour organiser vos variables, les classes, les méthodes et ainsi de suite. Voir doc

namespace Validation {
    export interface StringValidator {
        isAcceptable(s: string): boolean;
    }

    const lettersRegexp = /^[A-Za-z]+$/;
    const numberRegexp = /^[0-9]+$/;

    export class LettersOnlyValidator implements StringValidator {
        isAcceptable(s: string) {
            return lettersRegexp.test(s);
        }
    }

    export class ZipCodeValidator implements StringValidator {
        isAcceptable(s: string) {
            return s.length === 5 && numberRegexp.test(s);
        }
    }
}