¿Es posible usar getters / setters de definición de interfaz?

Question

¿Es posible usar getters / setters de definición de interfaz?

votos

50

Por el momento, TypeScriptno permite el uso métodos get / set (descriptores de acceso) en las interfaces. Por ejemplo:

interface I {
      get name():string;
}

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

Por otra parte, mecanografiado no permite el uso de expresiones de matriz de funciones en los métodos de clase: por ej .:

class C {
    private _name:string;

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

¿Hay alguna otra manera de que pueda utilizar un getter y setter en una definición de interfaz?

interface get set accessor typescript

Publicado el 11/10/2012 a las 12:15
fuente por usuario Ivan Popov

En otros idiomas...

4 respuestas

votos

16

Como complemento a las otras respuestas, si su deseo es definir una get valueen una interfaz, usted puede hacer esto:

interface Foo {
  readonly value: number;
}

let foo: Foo = { value: 10 };

foo.value = 20; //error

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

pero por lo que yo sé, y como otros han dicho, no hay manera actualmente para definir una propiedad de configuración sólo en la interfaz. Puede, sin embargo, mover la limitación a un error de tiempo de ejecución (útil durante el ciclo de desarrollo solamente):

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

No se recomienda la práctica ; sino una opción.

Respondida el 13/12/2016 a las 08:32
fuente por usuario Meirion Hughes

votos

2

En primer lugar, Letra de imprenta sólo es compatible gety setsintaxis al que apuntan a ECMAScript 5. Para lograr esto, hay que llamar al compilador

tsc --target ES5

Las interfaces no son compatibles con los captadores y definidores. Para obtener su código para compilar tendría que cambiarlo a

interface I { 
    getName():string;
}

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

Lo que hace mecanografiado apoyo es una sintaxis especial para campos de constructores. En su caso, usted podría tener

interface I {
    getName():string;
}

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

Observe cómo la clase Cno especifica el campo name. En realidad, se declara mediante azúcar sintáctica public name: stringen el constructor.

Como Sohnee señala, la interfaz es en realidad supone para ocultar cualquier detalles de implementación. En mi ejemplo, he elegido la interfaz para requerir un método de obtención de estilo de Java. Sin embargo, también una propiedad y luego se puede dejar que la clase decidir cómo implementar la interfaz.

Respondida el 11/10/2012 a las 12:45
fuente por usuario Valentin

votos

0

Uso de mecanografiado 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());

Véase el ejemplo de mecanografiado infantil .

Respondida el 25/05/2019 a las 17:30
fuente por usuario Jack

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

Puede especificar la propiedad en la interfaz, pero no se puede cumplir si se utilizan captadores y definidores, así:

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

En este ejemplo, la interfaz no obliga a la clase a utilizar captadores y definidores, podría haber usado una propiedad en lugar (ejemplo siguiente) - pero la interfaz se supone que ocultar estos detalles de implementación de todas formas, ya que es una promesa para el código de llamada sobre lo que se puede llamar.

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

Y por último, =>no está permitido para los métodos de clase - que podría comenzar una discusión en CodePlex si le parece que es un caso de uso de leña para ella. Aquí hay un ejemplo:

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

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

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