obține și a stabilit dactilografiat

Ezward a oferit deja un răspuns bun, dar am observat că unul dintre observațiile întreabă cum este utilizat. Pentru oameni ca mine, care dau peste această întrebare, m-am gândit că ar fi util să existe un link către documentația oficială privind getters și setteri pe site-ul typescript cum că aceasta explică bine, sperăm că va rămâne mereu la curent ca modificări sunt făcut, și arată exemple de utilizare:

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

În special, pentru cei care nu sunt familiarizați cu ea, rețineți că nu includ cuvântul „a lua“, într-un apel la un getter (și în mod similar pentru setteri):

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

Ar trebui să faci pur și simplu acest lucru:

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

având în vedere o clasă cum ar fi:

class foo {
  private _bar:boolean = false;

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

apoi getter „bar“ pentru proprietatea privată „_bar“ va fi numit.

Iată un exemplu de lucru pe care ar trebui să arate în direcția cea bună:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getters și setteri în JavaScript sunt funcții doar normale. Setterul este o funcție care are un parametru a cărui valoare este valoarea fiind stabilită.

Este foarte similar cu crearea unor metode comune, pune pur și simplu cuvântul cheie rezervat getsau setla început.

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

În acest caz, puteți sări peste tip de retur în get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Puteți scrie acest lucru

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 oferă getters și setteri care permit proprietatile obiectelor pentru a avea mai mult control asupra modului în care sunt accesate (getter) sau actualizat (setter) în afara obiectului. În loc accesarea direct sau actualizarea proprietatea unei funcții proxy este numit.

Exemplu:

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

Cred că , probabil , am obține de ce este atât de confuz. În exemplul dumneavoastră, ne - am dorit getters și setteri pentru _name. Dar vom realiza că , prin crearea getters și setteri pentru o variabilă de clasă care nu au legătură Name.

Gandeste-te la asta:

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

Codul de mai sus face următoarea:

1. getși de a setcrea getter și setter pentru yourCarTiresCount( nu pentrutiresCount ).

Getter este:

function() {
    return this.tiresCount ;
}

și setter este:

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

Adică, de fiecare dată când o facem new Car().yourCarTiresCount, reproducător se execută. Și pentru fiecare se new Car().yourCarTiresCount('7')execută setter.

2. Indirect crea getter, dar nu setter, pentru privat tireCount.

Dacă lucrați cu module typescript și încercați să adăugați un getter care este exportat, puteți face ceva de genul:

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

Apoi, într-un alt fișier aveți:

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