Declare classe à l'intérieur fonction usine exportée/fermeture

Question

Dire que j'ai le code dactylographiée suivant:

export const makeMyClass = function(a: string, b: boolean){ 

    const MyClass = function(){ 

    }; 

    MyClass.prototype.foo = function(){}; 

    MyClass.prototype.bar = function(){}; 

    return MyClass; 

} 

Je ne parviens pas à trouver comment convertir le code dans la fonction usine exportée en tapuscrit.

Par exemple, si je fais ceci:

export const makeMyClass = function(a: string, b: boolean): MyClass { 

     class MyClass { 

     } 

     // ... 

     return MyClass; 


    } 

tapuscrit se plaint en disant qu'il ne peut pas trouver le nom « MyClass ». S'il vous plaît supposer que j'ai besoin d'utiliser la fermeture exportée pour le bien de la question.

Answer 1

Si vous souhaitez donner un nom au type de la valeur de retour makeMyClass() qui est visible en dehors de la fonction, vous devez décrire sa structure comme un type d'interface dans une étendue externe. Au moins c'est comme ça que je comprends les implementation de class expressions de TypeScript.

Voici comment je le ferais dans votre cas. Une classe a un type d'instance (qui décrit les propriétés d'instance et les méthodes de classe) et un type de constructeur (qui décrit le constructeur et les méthodes statiques), donc nous devons décrire à la fois:

export interface MyClassInstance { 
    foo(): void; 
    bar(): void; 
    // define the rest of the public interface here 
} 
export interface MyClassConstructor { 
    new(): MyClassInstance; 
    readonly prototype: MyClassInstance; 
    // define any static methods here 
} 

Maintenant, vous pouvez déclarer que makeMyClass() retourne le type de constructeur:

export const makeMyClass = function(a: string, b: boolean): MyClassConstructor { 

    // implement the MyClassInstance/MyClassConstructor interfaces 
    class MyClass { 
    foo() { 
     // ... 
    } 
    bar() { 
     // ... 
    } 
    } 

    return MyClass; 
} 

Notez que cela est répétitif dans la mesure où vous déclarez la structure de classe à la fois à l'intérieur et à l'extérieur de la fonction. Si vous ajoutez une propriété ou une méthode aux interfaces, vous devrez ajouter une propriété correspondante à l'implémentation de la classe. Cela semble malheureusement inévitable, car vous ne pouvez pas exporter des types depuis des fonctions internes.

De toute façon, espérons que cela aide; bonne chance!