Come fare una classe di implementare una firma chiamata a macchina?

Question

Come fare una classe di implementare una firma chiamata a macchina?

voti

26

Ho definito la seguente interfaccia a macchina:

interface MyInterface {
    () : string;
}

Questa interfaccia introduce semplicemente una firma chiamata che non accetta parametri e restituisce una stringa. Come faccio a implementare questo tipo in una classe? Ho provato il seguente:

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

Il compilatore continua a dirmi che

'MyType' Classe dichiara interfaccia 'MyInterface', ma non implementarlo: Tipo 'MyInterface' richiede una firma chiamata, ma tipo 'MyType' manca uno

Come posso implementare la firma chiamata?

typescript

È pubblicato 07/10/2012 alle 15:22
fonte dall'utente Valentin

In altre lingue...

3 risposte

voti

4

Gli esempi di codice in questa risposta assumono la seguente dichiarazione:

var implementation: MyInterface;

Fornendo un'implementazione di un'interfaccia richiamabile

Come follow-up per la risposta accettata , come suggerito da alcuni dei suoi commentors, una funzione che corrisponde la firma chiamata dell'interfaccia implementa implicitamente l'interfaccia. Quindi è possibile utilizzare qualsiasi funzione di corrispondenza come un'implementazione.

Per esempio:

implementation = () => "Hello";

Non è necessario specificare esplicitamente che la funzione implementa l'interfaccia. Tuttavia, se si vuole essere esplicito, è possibile utilizzare un cast:

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

Fornire un'implementazione riutilizzabile

Se si vuole produrre un'implementazione riutilizzabile dell'interfaccia, come si farebbe normalmente con un'interfaccia Java o C #, basta memorizzare la funzione da qualche parte accessibile ai suoi consumatori.

Per esempio:

function Greet() {
    return "Hello";
}

implementation = Greet;

Fornire un'implementazione parametrizzata

Si consiglia di essere in grado di parametrizzare l'attuazione nello stesso modo in cui si potrebbe parametrizzare una classe. Ecco un modo per fare questo:

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

implementation = MakeGreeter("Hello");

Se si desidera che il risultato di essere digitato come interfaccia, basta impostare in modo esplicito il tipo di ritorno o il cast del valore da restituire.

Risposto il 23/12/2013 a 02:45
fonte dall'utente Sam

voti

1

Nel caso in cui l'interfaccia richiamabile dovrebbe avere altri metodi che si possono fare in questo modo:

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

Contro: greeter instanceof ConsoleGreeterèfalse

Risposto il 25/01/2018 a 08:08
fonte dall'utente teq

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

Le classi non può corrispondere tale interfaccia. Il più vicino è possibile ottenere, credo sia questa classe, che genererà il codice che corrisponde funzionalmente l'interfaccia (ma non secondo il compilatore).

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

Questo genererà il codice di lavoro, ma il compilatore si lamenterà che MyTypenon è richiamabile perché ha la firma new() = 'string'(anche se se lo si chiama con new, verrà restituito un oggetto).

Per creare qualcosa che corrisponde actally l'interfaccia senza lamentarsi compilatore, dovrete fare qualcosa del genere:

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