få og satt i Loggfila

Ezward har allerede gitt et godt svar, men jeg la merke til at en av kommentarene spør hvordan den brukes. For folk som meg som snubler over dette spørsmålet, tenkte jeg det ville være nyttig å ha en link til den offisielle dokumentasjonen på kundeskaffere og settere på Loggfila nettstedet som det forklarer det godt, vil forhåpentligvis alltid være up-to-date som endringene er gjort, og viser eksempel på bruk:

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

Spesielt for de som ikke er kjent med det, merk at du ikke innlemme ordet 'få' i en samtale til en getter (og tilsvarende for settere):

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

Du bør bare gjøre dette:

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

gitt en klasse som:

class foo {
  private _bar:boolean = false;

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

deretter på 'bar' getter for private '_bar' eiendom vil bli kalt.

Her er en fungerende eksempel som skal peke deg i riktig retning:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Kundeskaffere og settere i Javascript er bare normale funksjoner. Innstilleren er en funksjon som tar en parameter hvis verdi er den verdi som innstilles.

Det er veldig likt å lage vanlige metoder, enkelt sagt nøkkelordet reservert geteller seti begynnelsen.

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

I dette tilfellet kan du hoppe over retur-type i get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Du kan skrive dette

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 har getter og settere som tillater objektegenskaper for å ha større kontroll over hvordan de åpnes (getter) eller oppdatert (giver) utenfor objektet. I stedet for direkte tilgang til eller oppdatere egenskapen en proxy funksjonen kalles.

Eksempel:

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

Jeg tror jeg sannsynligvis få hvorfor er det så forvirrende. I ditt eksempel, ville vi kundeskaffere og settere for _name. Men vi oppnå det ved å lage kundeskaffere og settere for en uavhengig klassevariabel Name.

Tenk på dette:

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

Ovenfor koden gjør følgende:

1. getog setskape getter og setter for yourCarTiresCount( ikke fortiresCount ).

Den getter er:

function() {
    return this.tiresCount ;
}

og setter er:

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

Betydning, hver gang vi gjør new Car().yourCarTiresCount, går getter. Og for hver new Car().yourCarTiresCount('7')Setter går.

2. Indirekte skape getter, men ikke setter, for privat tireCount.

Hvis du arbeider med Loggfila moduler og prøver å legge til en getter som eksporteres, kan du gjøre noe som dette:

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

Så, i en annen fil du har:

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