Is het mogelijk om getters/setters te gebruiken in TypeScript-interfaces?

Ik wil een interface definiëren met een alleen-lezen eigenschap. Bijvoorbeeld;

interface foo {
    get bar():bool;
}

Dit geeft echter de syntaxisfout “expected ‘;'” op de balk. Ik heb mijn VisualStudio ingesteld om het ES5-doel te gebruiken, dus getters worden ondersteund. Is dit een beperking van interfaces? Kan dit in de toekomst veranderen; het is heel leuk om te kunnen doen.

Antwoord 1, autoriteit 100%

Alleen getter-eigenschappen zijn geïntroduceerd in Typescript 2.0:

interface foo {
    readonly bar: boolean;
}

Antwoord 2, autoriteit 17%

Ja, dit is een beperking van interfaces. Of de toegang tot het onroerend goed al dan niet met een getter wordt geïmplementeerd, is een implementatiedetail en zou dus geen onderdeel moeten zijn van de openbare interface. Zie ook deze vraag.

Als u een alleen-lezen-kenmerk nodig heeft dat in een interface is gespecificeerd, kunt u een getter-methode toevoegen:

interface foo {
    getAttribute() : string;
}

Antwoord 3, autoriteit 3%

Zoals @Vitaliy Ulantikov antwoordde, mag je de readonlymodifier gebruiken voor een property. Dit werkt precies als een getter.

interface Point {
    readonly x: number;
    readonly y: number;
}

Als een object letterlijkde interface implementeert, kun je een readonlyeigenschap niet overschrijven:

let p1: Point = { x: 10, y: 20 };
p1.x = 5; // error!

Maar wanneer een klassede interface implementeert, is er geen manier om te voorkomen dat deze wordt overschreven.

class PointClassBroken implements Point {
    // these are required in order to implement correctly
    x: number;
    y: number;
    constructor(x: number, y: number) {
        this.x = x
        this.y = y
    }
    changeCoordinates(x: number, y: number): void {
        this.x = x // no error!
        this.y = y // no error!
    }
}

Ik denk dat dat komt omdat wanneer je eigenschappen opnieuw declareert in de klassendefinitie, ze de eigenschappen van de interface overschrijven en niet langer alleen-lezen zijn.

Om dat op te lossen, gebruikt u readonlyvoor de eigenschappen rechtstreeks in de klasse die de interface implementeert

class PointClassFixed implements Point {
    readonly x: number;
    readonly y: number;
    constructor(x: number, y: number) {
        this.x = x
        this.y = y
    }
    changeCoordinates(x: number, y: number): void {
        this.x = x // error!
        this.y = y // error!
    }
}

Zie het zelf in de speeltuin.