Est-il possible d'utiliser getters / setters dans la définition de l'interface?

Question

Est-il possible d'utiliser getters / setters dans la définition de l'interface?

voix

50

À l'heure actuelle, TypeScriptne permet pas l' utilisation des méthodes get / set (de accesseurs) dans les interfaces. Par exemple:

interface I {
      get name():string;
}

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

En outre, tapuscrit ne permet pas l'expression utiliser le tableau de fonction dans les méthodes de classe: Ex .:

class C {
    private _name:string;

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

Est-il une autre façon que je peux utiliser un getter et setter sur une définition d'interface?

interface get set accessor typescript

Créé 11/10/2012 à 12:15
source utilisateur Ivan Popov

Dans d'autres langues...

4 réponses

voix

16

Pour compléter les autres réponses, si votre désir est de définir une get valuesur une interface, vous pouvez le faire:

interface Foo {
  readonly value: number;
}

let foo: Foo = { value: 10 };

foo.value = 20; //error

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

mais pour autant que je sache, et que d'autres ont mentionné, il n'y a aucun moyen actuellement de définir une propriété définie uniquement dans l'interface. Vous pouvez toutefois déplacer la limitation à une erreur d'exécution (utile au cours du cycle de développement uniquement):

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

Pratique non recommandée ; mais une option.

Créé 13/12/2016 à 11:32
source utilisateur Meirion Hughes

voix

2

Tout d'abord, Tapuscrit prend en charge uniquement getet setsyntaxe lorsque ECMAScript 5. Pour ciblage y parvenir, vous devez appeler le compilateur avec

tsc --target ES5

Interfaces ne prennent pas en charge accesseurs. Pour obtenir votre code pour vous compiler à changer à

interface I { 
    getName():string;
}

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

Qu'est-ce tapuscrit est pris en charge par une syntaxe particulière pour les champs dans les constructeurs. Dans votre cas, vous pourriez avoir

interface I {
    getName():string;
}

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

Remarquez comment la classe Cne précise pas le champ name. Il est en fait déclaré à l' aide de sucre syntaxique public name: stringdans le constructeur.

Comme Sohnee souligne, l'interface est censé fait pour cacher les détails de mise en œuvre. Dans mon exemple, j'ai choisi l'interface pour exiger une méthode de lecture de type java. Cependant, vous pouvez aussi une propriété, puis laisser la classe décider comment implémenter l'interface.

Créé 11/10/2012 à 12:45
source utilisateur Valentin

voix

0

L'utilisation tapuscrit 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());

Voir l' exemple sur tapuscrit Playground .

Créé 25/05/2019 à 17:30
source utilisateur Jack

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

Vous pouvez spécifier la propriété sur l'interface, mais vous ne pouvez pas appliquer si des accesseurs sont utilisés, comme ceci:

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

Dans cet exemple, l'interface ne force pas la classe à utiliser accesseurs, je aurais pu utiliser une propriété au lieu (exemple ci-dessous) - mais l'interface est censé cacher ces détails de mise en œuvre de toute façon car il est une promesse au code d'appel à ce qu'il peut appeler.

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

Enfin, =>n'est pas autorisé pour les méthodes de classe - vous pourriez commencer une discussion sur CodePlex si vous pensez qu'il ya un cas d'utilisation brûlant pour elle. Voici un exemple:

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

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

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