Hvordan lage en klasse gjennomføre en samtale signatur i Loggfila?

Question

Hvordan lage en klasse gjennomføre en samtale signatur i Loggfila?

stemmer

28

Jeg har definert følgende grensesnittet i Loggfila:

interface MyInterface {
    () : string;
}

Dette grensesnittet introduserer bare en samtale signatur som tar ingen parametere og returnerer en streng. Hvordan implementerer denne typen i en klasse du? Jeg har prøvd følgende:

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

Kompilatoren holder forteller meg at

Klasse 'MyType' erklærer interface 'MyInterface', men ikke implementerer det: Type 'MyInterface krever et kall signatur, men Type 'MyType' mangler en

Hvordan kan jeg gjennomføre samtalen signatur?

typescript

Publisert på 07/10/2012 klokken 14:22
kilden bruker Valentin

På andre språk...

3 svar

stemmer

4

Koden eksempler i dette svaret anta følgende erklæring:

var implementation: MyInterface;

Å tilveiebringe en implementering av et kall grensesnitt

Som en oppfølging til den aksepterte svaret , som foreslått av noen av sine commentors, en funksjon som samsvarer med grensesnitt oppfordring signatur implisitt implementerer grensesnittet. Så du kan bruke noen matchende fungere som en implementering.

For eksempel:

implementation = () => "Hello";

Du trenger ikke å eksplisitt angi at funksjonen implementerer grensesnittet. Men hvis du ønsker å være eksplisitt, kan du bruke en cast:

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

Å tilveiebringe et gjenbrukbart gjennomføring

Hvis du ønsker å produsere en gjenbrukbar implementering av grensesnittet som du normalt ville gjort med en Java eller C # grensesnitt, bare lagre funksjonen sted tilgjengelig for sine kunder.

For eksempel:

function Greet() {
    return "Hello";
}

implementation = Greet;

Å tilveiebringe en parameterisert gjennomføring

Det kan være lurt å kunne Parameterisér gjennomføring på samme måte som du kan Parameterisér en klasse. Her er én måte å gjøre dette på:

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

implementation = MakeGreeter("Hello");

Hvis du vil at resultatet skal være skrevet som grensesnitt, bare eksplisitt sette returtype eller kaste den verdien som skal returneres.

Svarte 23/12/2013 kl. 01:45
kilden bruker Sam

stemmer

1

I tilfellet hvis oppsigelige grensesnittet skal ha andre metoder du kan gjøre det slik:

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

Ulempen: greeter instanceof ConsoleGreetererfalse

Svarte 25/01/2018 kl. 08:08
kilden bruker teq

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

Klasser kan ikke matche det grensesnittet. Det nærmeste du kan få, jeg tror er denne klassen, noe som vil generere kode som funksjonelt passer grensesnittet (men ikke i henhold til kompilatoren).

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

Dette vil generere jobber koden, men kompilatoren vil klage på at MyTypeikke er callable fordi den har signaturen new() = 'string'(selv om hvis du kaller det med new, vil den returnere et objekt).

Å skape noe som actally matcher grensesnitt uten kompilatoren klager, må du gjøre noe som dette:

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