Comment faire une classe implémente une signature d'appel dactylographiée?

Question

Comment faire une classe implémente une signature d'appel dactylographiée?

voix

26

J'ai défini l'interface suivante dactylographiée:

interface MyInterface {
    () : string;
}

Cette interface présente simplement une signature d'appel qui ne prend aucun paramètre et renvoie une chaîne. Comment puis-je mettre ce type dans une classe? Je l'ai essayé ce qui suit:

class MyType implements MyInterface {
    function () : string {
        return Hello World.;
    }
}

Le compilateur ne cesse de me dire que

de la MyType 'classe déclare interface « MyInterface », mais ne met pas: Type « MyInterface » exige la signature d'appel, mais le type « MyType » manque un

Comment puis-je mettre en œuvre la signature d'appel?

typescript

Créé 07/10/2012 à 15:22
source utilisateur Valentin

Dans d'autres langues...

3 réponses

voix

4

Les exemples de code dans cette réponse supposent la déclaration suivante:

var implementation: MyInterface;

Fournir une implémentation d'une interface appelable

En tant que suivi de la réponse acceptée , comme suggéré par certains de ses commentors, une fonction qui correspond à la signature d'appel de l'interface implémente implicitement l'interface. Vous pouvez donc utiliser une fonction d'appariement comme une mise en œuvre.

Par exemple:

implementation = () => "Hello";

Vous n'avez pas besoin de spécifier explicitement que la fonction implémente l'interface. Toutefois, si vous voulez être explicite, vous pouvez utiliser un casting:

implementation = <MyInterface>() => "Hello";

Fournir une mise en œuvre réutilisable

Si vous voulez produire une implémentation de l'interface réutilisable comme vous le feriez normalement avec une interface Java ou C #, juste stocker la fonction quelque part accessible à ses consommateurs.

Par exemple:

function Greet() {
    return "Hello";
}

implementation = Greet;

Fournir une mise en œuvre paramétrés

Vous voudrez peut-être en mesure de paramétrer la mise en œuvre de la même manière que vous pourriez paramétriser une classe. Voici une façon de le faire:

function MakeGreeter(greeting: string) {
    return () => greeting;
}

implementation = MakeGreeter("Hello");

Si vous voulez que le résultat soit tapé comme l'interface, juste définir explicitement le type de retour ou coulée la valeur retournée.

Créé 23/12/2013 à 02:45
source utilisateur Sam

voix

1

Dans le cas où l'interface appelable devrait avoir d'autres méthodes que vous pouvez le faire comme ceci:

interface Greeter {
    (): void;
    setName(name: string): void;
}

class ConsoleGreeter {

    private constructor( // constructable via `create()`
        private name = 'world'
    ) {}

    public call(): void {
        console.log(`Hello ${this.name}!`);
    }

    public setName(name: string) {
        this.name = name;
    }

    public static create(): Greeter {
        const instance = new ConsoleGreeter();
        return Object.assign(
            () => instance.call(),
            {
                setName: (name: string) => instance.setName(name)
                // ... forward other methods
            }
        );
    }
}

const greeter = ConsoleGreeter.create();
greeter.setName('Dolly');
greeter(); // prints 'Hello Dolly!'

Le seul inconvénient: greeter instanceof ConsoleGreeterestfalse

Créé 25/01/2018 à 08:08
source utilisateur teq

Peter Olson · Accepted Answer · 2012-10-07 16:32

Les classes ne peuvent pas correspondre à cette interface. Le plus proche que vous pouvez obtenir, je pense est cette classe, qui va générer un code qui correspond fonctionnellement à l'interface (mais pas selon le compilateur).

class MyType implements MyInterface {
  constructor {
    return "Hello";
  }
}
alert(MyType());

Cela va générer le code de travail, mais le compilateur se plaindra que MyTypen'est pas appelable parce qu'il a la signature new() = 'string'(même si si vous l' appelez avec new, il retournera un objet).

Pour créer quelque chose qui correspond actally l'interface sans se plaindre du compilateur, vous devez faire quelque chose comme ceci:

var MyType = (() : MyInterface => {
  return function() { 
    return "Hello"; 
  }
})();
alert(MyType());