Is het mogelijk om getters / setters gebruiken in de interface definitie?

Question

Is het mogelijk om getters / setters gebruiken in de interface definitie?

stemmen

50

Op dit moment, TypeScriptstaat niet toe dat het gebruik get / set methodes (accessors) in interfaces. Bijvoorbeeld:

interface I {
      get name():string;
}

class C implements I {
      get name():string {
          return null;
      } 
}

bovendien heeft typoscript niet toe dat het gebruik Array Functie Expression in de klas methoden: voor ex .:

class C {
    private _name:string;

    get name():string => this._name;
}

Is er een andere manier kan ik een getter en setter op een interface definitie gebruiken?

interface get set accessor typescript

De vraag is gesteld op 11/10/2012 om 12:15
bron van user Ivan Popov

In andere talen...

4 antwoorden

stemmen

16

Om de andere antwoorden aan te vullen, als uw wens is om een te definiëren get valueop een interface, kunt u dit doen:

interface Foo {
  readonly value: number;
}

let foo: Foo = { value: 10 };

foo.value = 20; //error

class Bar implements Foo {
  get value() {
    return 10;
  }
}

maar voor zover ik weet, en zoals anderen al hebben gezegd, is er geen manier momenteel om een set-enige pand in de interface definiëren. U kunt echter, bewegen de beperking tot een run-time error (handig tijdens de ontwikkelingscyclus only):

interface Foo {
  /* Set Only! */
  value: number;
}

class Bar implements Foo {
  _value:number;
  set value(value: number) {
    this._value = value;
  }
  get value() {
    throw Error("Not Supported Exception");
  }
}

Niet aanbevolen praktijk ; maar een optie.

antwoordde op 13/12/2016 om 11:32
bron van user Meirion Hughes

stemmen

2

Allereerst Typescript ondersteunt alleen geten setsyntax als targeting ECMAScript 5. Om dit te bereiken, moet je de compiler te bellen met

tsc --target ES5

Interfaces ondersteunen geen getters en setters. Om uw code te compileren krijg je zou hebben om het te veranderen naar

interface I { 
    getName():string;
}

class C implements I { 
    getName():string {
          return null;
    }   
}

Wat typoscript ondersteunt is een speciale syntaxis voor velden in constructeurs. In uw geval, zou je hebt

interface I {
    getName():string;
}

class C implements I {
    constructor(public name: string) {
    }
    getName():string {
        return name;
    }
}

Merk op hoe de klasse Chet veld niet specificeert name. Het is eigenlijk gedeclareerd met syntactische suiker public name: stringin de constructor.

Zoals Sohnee opmerkt, wordt de interface eigenlijk zou moeten elke implementatie details te verbergen. In mijn voorbeeld heb ik gekozen voor de interface naar een java-stijl getter methode nodig. U kunt echter ook een woning en laat de klasse beslissen hoe de interface implementeren.

antwoordde op 11/10/2012 om 12:45
bron van user Valentin

stemmen

0

Met behulp van typoscript 3.4:

interface IPart {
    getQuantity(): number;
}

class Part implements IPart {
    private quantity: number;
    constructor(quantity: number) {
        this.quantity = quantity;
    }
    public getQuantity = (): number => {
        return this.quantity;
    };
}

let part = new Part(42);

// When used in typescript, quantity is not accessible.
// However, when compiled to javascript it will log '42'.
console.log(part.quantity);

// Logs '42'.
console.log(part.getQuantity());

Zie voorbeeld Typescript Playground .

antwoordde op 25/05/2019 om 17:30
bron van user Jack

Fenton · Accepted Answer · 2012-10-11 13:03

U kunt de woning op de interface te geven, maar je kunt niet afdwingen of getters en setters worden gebruikt, zoals deze:

interface IExample {
    Name: string;
}

class Example implements IExample {
    private _name: string = "Bob";

    public get Name() {
        return this._name;
    }

    public set Name(value) {
        this._name = value;
    }
}

var example = new Example();
alert(example.Name);

In dit voorbeeld, is de interface niet dwingen de klas te getters en setters gebruiken, kon ik een object hebben gebruikt in plaats (voorbeeld hieronder) - maar de interface is de bedoeling om deze implementatie details hoe dan ook te verbergen als het is een belofte voor de oproepende code over wat het kan noemen.

interface IExample {
    Name: string;
}

class Example implements IExample {
    // this satisfies the interface just the same
    public Name: string = "Bob";
}

var example = new Example();
alert(example.Name);

En tot slot, =>is niet toegestaan voor methoden van de klasse - kon je een discussie over Codeplex beginnen als je denkt dat er een brandende use case voor. Hier is een voorbeeld:

class Test {
    // Yes
    getName = () => 'Steve';

    // No
    getName() => 'Steve';

    // No
    get name() => 'Steve';
}