get és set géppel

Ezward már nyújtott jó válasz, de azt vettem észre, hogy az egyik hozzászólás azt kérdezi, hogyan használják. Azoknak az embereknek, mint én, aki belebotlott ezt a kérdést, azt gondoltam, hogy hasznos lenne, hogy egy linket a hivatalos dokumentáció get és set metódusok a géppel honlapján, hogy magyarázza azt is, remélhetőleg mindig maradni up-to-date a változások készült, és azt mutatja, például használat:

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

Különösen azoknak, akik nem ismerik azt, vegye figyelembe, hogy nem építenek be a „kap” egy hívást egy getter (és hasonlóan alkotóinak):

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

Akkor csak ezt:

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

adott osztály, mint:

class foo {
  private _bar:boolean = false;

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

akkor a „bar” getter privát "_bar tulajdonság kerül meghívásra.

Itt egy működő példa, hogy meg pont akkor a helyes irányba:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Get és alkotóinak JavaScript csak normális funkcióit. A szetter egy olyan funkció, hogy vesz egy paraméter, melynek értéke az az érték meghatározásakor.

Ez nagyon hasonlít a létrehozása, közös módszerek, egyszerűen tegye a kulcsszó fenntartott getvagy setaz elején.

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

Ebben az esetben akkor hagyja visszatérési típus get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Írhatsz ezt

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 kínál get és set metódusok, amelyek lehetővé teszik objektum tulajdonságait, hogy jobban kézben, hogyan lehet hozzáférni (getter) vagy frissített (szetter) kívül az objektum. Ahelyett, hogy közvetlenül elérő vagy frissítése a tulajdonság egy proxy funkciót nevezik.

Példa:

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

Azt hiszem, talán kap, miért van ez így zavaros. A példád akartunk get és set metódusok számára _name. De elérni, hogy hozzon létre get és set metódusok egy független osztály változó Name.

Ezt fontold meg:

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

Fenti kód nem következőket:

1. getés sethozzon létre getter és setter yourCarTiresCount( nemtiresCount ).

A getter:

function() {
    return this.tiresCount ;
}

és a szetter van:

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

Jelentése, minden alkalommal teszünk new Car().yourCarTiresCount, getter fut. És minden new Car().yourCarTiresCount('7')szetter fut.

2. Közvetve létre getter, de nem a szetter, magán tireCount.

Ha dolgozik a géppel modulok és próbálják felvenni a getter exportáljuk, akkor valami hasonlót:

// 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;
    },
});

Aztán egy másik fájl van:

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