Wie eine Klasse machen Anruf Signatur in Typoskript implementieren?

Question

Wie eine Klasse machen Anruf Signatur in Typoskript implementieren?

stimmen

26

Ich habe die folgende Schnittstelle in Typoskript definiert:

interface MyInterface {
    () : string;
}

Diese Schnittstelle stellt einfach einen Anruf Signatur, die keine Parameter und gibt einen String. Wie implementiere ich diese Art in einer Klasse? Ich habe folgendes versucht:

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

Der Compiler sagt mir, dass

Class ‚MyType‘ erklärt Schnittstelle ‚MyInterface‘ sie aber nicht umsetzen: Typ ‚MyInterface‘ erfordert einen Aufruf Signatur, sondern Typ ‚MyType‘ fehlt ein

Wie kann ich den Anruf Signatur implementieren?

typescript

Veröffentlicht am 07/10/2012 um 15:22
quelle vom benutzer Valentin

In anderen Sprachen...

3 antworten

stimmen

4

Die Codebeispiele in dieser Antwort übernehmen die folgende Erklärung ab:

var implementation: MyInterface;

Die Bereitstellung einer Implementierung einer aufrufbare Schnittstelle

Als Follow-up zu der akzeptierten Antwort , wie einige seiner commentors vorgeschlagen, eine Funktion , die der Aufruf Unterschrift Schnittstelle entspricht implizit die Schnittstelle implementiert. So können Sie jede passende Funktion als Implementierung verwenden.

Beispielsweise:

implementation = () => "Hello";

Sie müssen nicht explizit angeben, dass die Funktion die Schnittstelle implementiert. Wenn Sie jedoch explizit sein wollen, können Sie eine Besetzung verwenden:

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

Die Bereitstellung einer wiederverwendbare Implementierung

Wenn Sie eine wiederverwendbare Implementierung der Schnittstelle, wie Sie normalerweise würde mit einem Java oder C # Schnittstelle herstellen möchten, speichern Sie nur die Funktion irgendwo zugänglich zu den Verbrauchern.

Beispielsweise:

function Greet() {
    return "Hello";
}

implementation = Greet;

Die Bereitstellung einer parametrisiert Implementierung

Sie können in der Lage sein, die Umsetzung in der gleichen Art und Weise parametrisieren, dass Sie eine Klasse parametrisieren könnten. Hier ist eine Möglichkeit, dies zu tun:

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

implementation = MakeGreeter("Hello");

Wenn Sie möchten, das Ergebnis als Schnittstelle eingegeben werden, setzen Sie nur explizit den Rückgabetyp oder Guss der Wert zurückgegeben wird.

Beantwortet am 23/12/2013 um 02:45
quelle vom benutzer Sam

stimmen

1

Im Fall, wenn aufrufbare Schnittstelle sollten andere Methoden haben Sie es wie folgt tun:

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!'

Nachteil: greeter instanceof ConsoleGreeteristfalse

Beantwortet am 25/01/2018 um 08:08
quelle vom benutzer teq

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

Klassen können nicht diese Schnittstelle entsprechen. Die nächstgelegene Sie bekommen können, denke ich, ist diese Klasse, der Code generiert, die funktionell entspricht die Schnittstelle (aber nicht nach dem Compiler).

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

Dies wird erzeugt Code arbeiten, aber die Compiler beschweren MyTypeist nicht aufrufbar , weil es die Unterschrift hat new() = 'string'(obwohl , wenn Sie es mit aufrufen new, wird es ein Objekt zurückgeben).

Um etwas zu schaffen, das actally die Schnittstelle übereinstimmt, ohne den Compiler beschweren, müssen Sie so etwas wie dies zu tun:

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