get et set dactylographiée

Ezward a déjà fourni une bonne réponse, mais je remarque que l'un des commentaires demande comment il est utilisé. Pour les gens comme moi qui tombent sur cette question, je pensais que ce serait utile d'avoir un lien vers la documentation officielle sur des accesseurs sur le site Tapuscrit comme cela explique bien, nous l'espérons toujours rester à jour que les changements sont fait, et montre un exemple d'utilisation:

http://www.typescriptlang.org/docs/handbook/classes.html

En particulier, pour ceux qui ne le connaissent pas, notez que vous n'intégrez pas le mot « get » dans un appel à une méthode de lecture (et de même pour setters):

var myBar = myFoo.getBar(); // wrong    
var myBar = myFoo.get('bar');  // wrong

Vous devez simplement faire ceci:

var myBar = myFoo.bar;  // correct (get)
myFoo.bar = true;  // correct (set) (false is correct too obviously!)

étant donné une classe comme:

class foo {
  private _bar:boolean = false;

  get bar():boolean {
    return this._bar;
  }
  set bar(theBar:boolean) {
    this._bar = theBar;
  }
}

alors la propriété « bar » getter pour la privée « _bar » sera appelée.

Voici un exemple de travail qui devrait vous orienter dans la bonne direction:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

    set Name(val) {
        this._name = val;
    }
}

Accesseurs en JavaScript sont juste des fonctions normales. Le dispositif de réglage est une fonction qui prend un paramètre dont la valeur est la valeur étant réglée.

Il est très similaire à la création de méthodes communes, il suffit de mettre le mot - clé réservé getou setau début.

class Name{
    private _name: string;

    getMethod(): string{
        return this._name;
    }

    setMethod(value: string){
        this._name = value
    }

    get getMethod1(): string{
        return this._name;
    }

    set setMethod1(value: string){
        this._name = value
    }
}

class HelloWorld {

    public static main(){

        let test = new Name();

        test.setMethod('test.getMethod() --- need ()');
            console.log(test.getMethod());

        test.setMethod1 = 'test.getMethod1 --- no need (), and used = for set ';
            console.log(test.getMethod1);
    }
}
HelloWorld.main();

Dans ce cas, vous pouvez ignorer le type de retour get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Vous pouvez écrire

class Human {
    private firstName : string;
    private lastName : string;

    constructor (
        public FirstName?:string, 
        public LastName?:string) {

    }

    get FirstName() : string {
        console.log("Get FirstName : ", this.firstName);
        return this.firstName;
    }
    set FirstName(value : string) {
        console.log("Set FirstName : ", value);
        this.firstName = value;
    } 

    get LastName() : string {
        console.log("Get LastName : ", this.lastName);
        return this.lastName;
    }
    set LastName(value : string) {
        console.log("Set LastName : ", value);
        this.lastName = value;
    } 

}

TS propose des accesseurs qui permettent aux propriétés de l' objet d'avoir plus de contrôle sur la façon dont ils sont accessibles (getter) ou mis à jour (setter) en dehors de l'objet. Au lieu d'accéder directement ou mettre à jour la propriété d' une fonction proxy est appelée.

Exemple:

class Person {
    constructor(name: string) {
        this._name = name;
    }

    private _name: string;

    get name() {
        return this._name;
    }

    // first checks the length of the name and then updates the name.
    set name(name: string) {
        if (name.length > 10) {
            throw new Error("Name has a max length of 10");
        }

        this._name = name;  
    }

    doStuff () {
        this._name = 'foofooooooofoooo';
    }


}

const person = new Person('Willem');

// doesn't throw error, setter function not called within the object method when this._name is changed
person.doStuff();  

// throws error because setter is called and name is longer than 10 characters
person.name = 'barbarbarbarbarbar';  

Je pense que je reçois sans doute pourquoi il est si déroutant. Dans votre exemple, nous voulions accesseurs pour _name. Mais nous y parvenons en créant des accesseurs pour une variable de classe sans rapport Name.

Considère ceci:

class Car{
    private tiresCount = 4;
    get yourCarTiresCount(){
        return this.tiresCount ;
    }
    set yourCarTiresCount(count) {
        alert('You shouldn't change car tire count')
    }
}

Code ci-dessus ne suit:

1. getet setcréer getter et setter pour yourCarTiresCount( pastiresCount ).

Le getter est:

function() {
    return this.tiresCount ;
}

et le poseur est:

function(count) {
    alert('You shouldn't change car tire count');
}

Ce qui signifie, chaque fois que nous faisons new Car().yourCarTiresCount, getter court. Et pour tous les new Car().yourCarTiresCount('7')runs setter.

2. Indirectement créer getter, mais pas le compositeur, pour un usage privé tireCount.

Si vous travaillez avec des modules dactylographiées et essayez d'ajouter un getter qui est exporté, vous pouvez faire quelque chose comme ceci:

// dataStore.ts
export const myData: string = undefined;  // just for typing support
let _myData: string;  // for memoizing the getter results

Object.defineProperty(this, "myData", {
    get: (): string => {
        if (_myData === undefined) {
            _myData = "my data";  // pretend this took a long time
        }

        return _myData;
    },
});

Puis, dans un autre fichier que vous avez:

import * as dataStore from "./dataStore"
console.log(dataStore.myData); // "my data"