Hoe maak je een klasse implementeren van een handtekening oproep in Typescript?

Question

Hoe maak je een klasse implementeren van een handtekening oproep in Typescript?

stemmen

26

Ik heb de volgende interface van de schrijfmachine gedefinieerd:

interface MyInterface {
    () : string;
}

Deze interface introduceert gewoon een oproep handtekening die geen parameters neemt en geeft een string. Hoe kan ik deze soort in een klas te implementeren? Ik heb het volgende geprobeerd:

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

De compiler houdt me te vertellen dat

Class 'MyType' verklaart interface van 'MyInterface' maar niet ten uitvoer te leggen: Type 'MyInterface' vraagt om een handtekening gesprek, maar Type 'MyType' ontbeert een

Hoe kan ik de handtekening gesprek te voeren?

typescript

De vraag is gesteld op 07/10/2012 om 15:22
bron van user Valentin

In andere talen...

3 antwoorden

stemmen

4

De code voorbeelden in dit antwoord uitgegaan van de volgende verklaring:

var implementation: MyInterface;

Het verstrekken van een implementatie van een vervroegd aflosbaar-interface

Als follow-up van de geaccepteerde antwoord , zoals voorgesteld door een aantal van zijn commentors, een functie die overeenkomt met call handtekening van de interface impliciet implementeert de interface. Zo kunt u het even welke passende functie te gebruiken als een implementatie.

Bijvoorbeeld:

implementation = () => "Hello";

Je hoeft niet te expliciet dat de functie implementeert de interface. Echter, als je wilt expliciet te zijn, kunt u een cast te gebruiken:

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

Het verstrekken van een herbruikbare implementatie

Wilt u een herbruikbare uitvoering van de interface te produceren zoals je normaal zou met een Java of C #-interface, alleen de functie ergens toegankelijk zijn voor de consument op te slaan.

Bijvoorbeeld:

function Greet() {
    return "Hello";
}

implementation = Greet;

Het verstrekken van een geparametriseerd implementatie

Misschien wilt u in staat zijn om de uitvoering op dezelfde manier dat je een klasse zou kunnen parametreren parametreren. Hier is een manier om dit te doen:

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

implementation = MakeGreeter("Hello");

Als u wilt dat de uitkomst kan worden getypeerd als de interface, net expliciet de terugkeer type of gegoten de waarde wordt geretourneerd.

antwoordde op 23/12/2013 om 02:45
bron van user Sam

stemmen

1

In het geval als opvraagbare-interface moeten andere methoden die u kunt doen als dit:

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

Nadeel: greeter instanceof ConsoleGreeterisfalse

antwoordde op 25/01/2018 om 08:08
bron van user teq

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

Klassen kunnen niet overeen met die interface. Het dichtst je kunt krijgen, ik denk dat deze klasse, welke code die functioneel overeenkomt met de interface zal genereren (maar niet volgens de compiler).

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

Dit zal genereren werkende code, maar de compiler zal klagen dat MyTypeis niet vervroegd aflosbaar omdat het de handtekening new() = 'string'(hoewel als je het bellen new, zal het een object te retourneren).

Om iets dat actally overeenkomt met de interface zonder de compiler klagen te maken, dan moet je zoiets als dit:

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