Hogyan készítsünk egy osztály végre egy hívás aláírás géppel?

Question

Hogyan készítsünk egy osztály végre egy hívás aláírás géppel?

szavazat

26

Megadtam az alábbi felületen géppel:

interface MyInterface {
    () : string;
}

Ez a felület egyszerűen bevezeti a hívást aláírás nem veszi paramétereket és visszatér egy húr. Hogyan alkalmazzák ezt a típusú egy osztályban? Megpróbáltam a következő:

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

A fordító mondogatja nekem, hogy

Osztályú MyType azt mondja interface „MyInterface”, de nem hajtják végre: Típus „MyInterface” igényel hívás aláírást, de típus „MyType” hiányzik egy

Hogyan végre a hívást aláírás?

typescript

A kérdést 07/10/2012 15:22
a forrás felhasználó Valentin

Más nyelveken...

3 válasz

szavazat

4

A kód példák a válasz vállalja a következő nyilatkozatot teszi:

var implementation: MyInterface;

Biztosítva végrehajtása lehívható interfész

Ennek nyomon követése az elfogadott válasz , ahogy azt néhány commentors, egy függvény, amely megegyezik a felület hívását aláírása hallgatólagosan megvalósítja az interfészt. Így használhatja-e megfelelő funkciót, mint a végrehajtást.

Például:

implementation = () => "Hello";

Nem kell meghatároznia, hogy a függvény végrehajtja a felületet. Azonban, ha azt akarjuk, hogy explicit, akkor használja a szereplők:

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

Biztosítása egy újrafelhasználható végrehajtása

Ha azt szeretnénk, hogy készítsen egy újrafelhasználható végrehajtását a felület, mint amit normális esetben egy Java vagy C # felület, csak tárolja a funkció valahol elérhető a fogyasztók számára.

Például:

function Greet() {
    return "Hello";
}

implementation = Greet;

Biztosítása paraméterezni végrehajtása

Érdemes lehet, hogy képes legyen paramétereket a végrehajtás ugyanúgy, hogy esetleg be paramétereket egy osztály. Itt van egy módja annak, hogy ezt:

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

implementation = MakeGreeter("Hello");

Ha szeretné az eredményt kell beírni, mint a felület, csak kifejezetten meg a visszatérési típusa vagy öntött az értéket vissza.

Válaszolt 23/12/2013 02:45
a forrás felhasználó Sam

szavazat

1

Abban az esetben, ha a lehívható felületet kell más módszerekkel lehet csinálni, mint ez:

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

Hátránya: greeter instanceof ConsoleGreeterazfalse

Válaszolt 25/01/2018 08:08
a forrás felhasználó teq

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

Osztályok nem egyezik felületet. A legközelebb akkor kap, azt hiszem, ez osztály, amely generál kódot szervesen illeszkedik az interfész (de nem megfelelően a fordító).

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

Ez létrehoz működő kód, de a fordító panaszkodnak, hogy MyTypenem mondható, mert az aláírás new() = 'string'(bár ha hívhatja new, hogy vissza fog térni egy tárgy).

Létrehozni valamit, ami actally megegyezik a felület nélkül, a fordító panaszkodik, akkor meg kell csinálni valamit, mint ez:

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