Comment définir la propriété statique de la Machine a ecrire l'interface

Suivez @Duncan @Bartvds réponse, ici, de fournir de manière pratique, après des années passées.

À ce point après Tapuscrit de 1,5 publié (@Jun 15 '15), votre utile interface

interface MyType {
    instanceMethod();
}

interface MyTypeStatic {
    new():MyType;
    staticMethod();
}

peut être mis en œuvre avec l'aide de la décoratrice.

/* class decorator */
function staticImplements<T>() {
    return <U extends T>(constructor: U) => {constructor};
}

@staticImplements<MyTypeStatic>()   /* this statement implements both normal interface & static interface */
class MyTypeClass { /* implements MyType { */ /* so this become optional not required */
    public static staticMethod() {}
    instanceMethod() {}
}

Renvoie à mon commentaire sur github question ouverte 13462.

résultat visuel:
Erreur de compilation avec un soupçon de méthode statique manquant.

Après statique de la méthode mise en œuvre, conseil pour la méthode manquante.

Compilation passé après les deux statique de l'interface et l'interface normale remplies.

Vous pouvez définir l'interface normalement:

interface MyInterface {
    Name:string;
}

mais vous ne pouvez pas tout

class MyClass implements MyInterface {
    static Name:string; //typescript won't care about this field
    Name:string;         //and demand this one instead
}

Pour exprimer qu'une classe doit suivre cette interface pour ses propriétés statiques vous avez besoin d'un peu de ruse:

var MyClass: MyInterface;
MyClass = class {
    static Name:string; //if the class doesn't have that field it won't compile
}

Vous pouvez même garder le nom de la classe, Tapuscrit (2.0) ne sera pas l'esprit:

var MyClass: MyInterface;
MyClass = class MyClass {
    static Name:string; //if the class doesn't have that field it won't compile
}

Si vous wan pas à hériter de plusieurs interfaces, de manière statique, vous aurez à les fusionner en premier dans une nouvelle:

interface NameInterface {
    Name:string;
}
interface AddressInterface {
    Address:string;
}
interface NameAndAddressInterface extends NameInterface, AddressInterface { }
var MyClass: NameAndAddressInterface;
MyClass = class MyClass {
    static Name:string; //if the class doesn't have that static field code won't compile
    static Address:string; //if the class doesn't have that static field code won't compile
}

Ou si vous ne voulez pas de nom fusionné interface que vous pouvez faire:

interface NameInterface {
    Name:string;
}
interface AddressInterface {
    Address:string;
}
var MyClass: NameInterface & AddressInterface;
MyClass = class MyClass {
    static Name:string; //if the class doesn't have that static field code won't compile
    static Address:string; //if the class doesn't have that static field code won't compile
}

De travail exemple

Si vous êtes à la recherche pour définir une classe statique (ie. toutes les méthodes/propriétés statiques), vous pouvez faire quelque chose comme ceci:

interface MyStaticClassInterface {
  foo():string;
}

var myStaticClass:MyStaticClassInterface = {
  foo() {
    return 'bar';
  }
};

Dans ce cas, la statique de la "classe" est vraiment juste une plaine-ol-js-objet qui implémente toutes les méthodes de MyStaticClassInterface

J'ai trouvé une façon de le faire (sans décorateurs) pour mon cas d'utilisation spécifiques.

Le rôle important que les vérifications pour les membres statiques est IObjectClass et à l'aide de cls: IObjectClass<T> dans le createObject méthode:

//------------------------
//Library
//------------------------
interface IObject {
  id: number;
}
interface IObjectClass<T> {
  new(): T;
  table_name: string;
}
function createObject<T extends IObject>(cls: IObjectClass<T>, data:Partial<T>):T {
  let obj:T = (<any>Object).assign({},
    data,
    {
      id: 1,
      table_name: cls.table_name,
    }
  )
  return obj;
}

//------------------------
//Implementation
//------------------------
export class User implements IObject {
  static table_name: string = 'user';
  id: number;
  name: string;
}

//------------------------
//Application
//------------------------
let user = createObject(User, {name: 'Jimmy'});
console.log(user.name);

Oui, c'est possible. Voici la solution

export interface Foo {

    test(): void;
}

export namespace Foo {

    export function statMethod(): void {
        console.log(2);
    }

}