Lehetséges használni getter / alkotóinak interfész definíció?

Question

Lehetséges használni getter / alkotóinak interfész definíció?

szavazat

50

Abban a pillanatban, TypeScriptnem teszi lehetővé a használatát get / set módszerekkel (accessors) interfésszel. Például:

interface I {
      get name():string;
}

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

továbbá géppel nem engedi használni Array függvény Expression osztályban módszerek: az ex .:

class C {
    private _name:string;

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

Van más mód arra, hogy használja a getter és setter Egy interfész definíció?

interface get set accessor typescript

A kérdést 11/10/2012 12:15
a forrás felhasználó Ivan Popov

Más nyelveken...

4 válasz

szavazat

16

Kiegészítve az egyéb választ, ha a vágy, hogy meghatározza egy get valueegy felületen, akkor tegye a következőket:

interface Foo {
  readonly value: number;
}

let foo: Foo = { value: 10 };

foo.value = 20; //error

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

de amennyire én tudom, és a többiek már említettük, nincs módja jelenleg, hogy határozza meg a kizárólag ingatlan a felületen. Akkor azonban elmozdulhat a kizárólag a run-time error (hasznos a fejlesztés során ciklus esetében):

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");
  }
}

Nem ajánlott gyakorlat ; de egy lehetőséget.

Válaszolt 13/12/2016 11:32
a forrás felhasználó Meirion Hughes

szavazat

2

Először is, géppel csak akkor támogatja get, és setszintaxist, amikor célozzuk EcmaScript 5. Ennek eléréséhez meg kell hívni a fordító,

tsc --target ES5

Interfészek nem támogatják a get és set metódusok. Ahhoz, hogy a kódot összeállításához meg kellett volna változtatni, hogy

interface I { 
    getName():string;
}

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

Milyen géppel nem támogatja egy speciális szintaxis mezők konstruktőrök. Az Ön esetében, akkor lehetett volna

interface I {
    getName():string;
}

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

Figyeljük meg, hogy osztály Cnem határozza meg a területen name. Ez valójában deklarálva szintaktikai cukor public name: stringa kivitelező.

Ahogy Sohnee rámutat, a felület ténylegesen kéne elrejteni végrehajtásának részleteit. Az én például azt választotta, hogy a felület szükség van a Java-style getter módszer. Azonban, akkor is egy tulajdonság, majd hagyja, hogy az osztály dönti el, hogyan hajtsák végre a felületet.

Válaszolt 11/10/2012 12:45
a forrás felhasználó Valentin

szavazat

0

Használata géppel 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());

Lásd például géppel Playground .

Válaszolt 25/05/2019 17:30
a forrás felhasználó Jack

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

Megadhatja az ingatlan a felület, de nem tudja érvényesíteni, hogy get és set metódusok használnak, mint ez:

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);

Ebben a példában a felület nem kényszeríti az osztályt használni get és set metódusok, tudtam volna használni a tulajdonság helyett (az alábbi példát) - de a felület állítólag elrejteni ezeket a végrehajtás részleteit egyébként, mivel ez egy ígéret, hogy a hívó kód arról, hogy mit lehet hívni.

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);

És végül, =>nem engedélyezett osztály módszerek - meg tudná kezdeni a vitát codeplex ha úgy gondolja, van egy égő használat esetében is. Itt egy példa:

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

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

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