te krijgen en in typoscript

Ezward heeft reeds een goed antwoord, maar ik merkte dat een van de opmerkingen vraagt ​​hoe het wordt gebruikt. Voor mensen zoals ik, die struikelen over deze vraag, ik dacht dat het handig om een ​​link naar de officiële documentatie over getters en setters op de Typescript website hebben als die verklaart het goed zou komen, zal hopelijk altijd up-to-date veranderingen zijn gemaakt, en toont voorbeeld gebruik:

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

In het bijzonder voor degenen die niet bekend zijn met het, er rekening mee dat u niet het woord 'get' op te nemen in een oproep naar een getter (en hetzelfde geldt voor setters):

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

U moet dit gewoon doen:

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

gegeven een klasse, zoals:

class foo {
  private _bar:boolean = false;

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

dan is de 'bar' getter voor de particuliere '_bar' eigenschap zal worden genoemd.

Hier is een werkend voorbeeld dat je moet wijzen in de goede richting:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getters en setters in JavaScript zijn normale functies. De aanbrenginrichting is een functie die een parameter waarvan de waarde de waarde die wordt voorgeschreven.

Het is zeer vergelijkbaar met het creëren van gemeenschappelijke methoden, simpel gezegd het trefwoord gereserveerd getof setbij het begin.

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

In dit geval kun je overslaan return type in get getMethod1() {

    get getMethod1() {
        return this._name;
    }

U kunt dit schrijf

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 biedt getters en setters die het mogelijk maken object eigenschappen om meer controle over hoe ze worden benaderd (getter) of geactualiseerd (setter) hebben buiten van het object. In plaats van direct toegang tot of het bijwerken van de woning een proxy functie wordt aangeroepen.

Voorbeeld:

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

Ik denk dat ik waarschijnlijk waarom is het zo verwarrend. In uw voorbeeld, wilden we getters en setters voor _name. Maar we dat bereiken door het creëren van getters en setters voor een niet-verwante klasse variabele Name.

Overweeg dit:

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

Bovenstaande code doet volgende:

1. geten setcreëren getter en setter voor yourCarTiresCount( niet voortiresCount ).

De getter is:

function() {
    return this.tiresCount ;
}

en de aanbrenginrichting is:

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

Betekenis, elke keer als we doen new Car().yourCarTiresCount, getter loopt. En voor elke new Car().yourCarTiresCount('7')setter runs.

2. Indirect creëren getter, maar niet de zetter, voor prive tireCount.

Als u werkt met typoscript modules en proberen een getter die wordt geëxporteerd toe te voegen, kun je zoiets als dit te doen:

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

Dan, in een ander bestand dat u hebt:

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