získat a nastavit na stroji

Ezward již poskytla dobrou odpověď, ale všiml jsem si, že jeden z komentářů se ptá, jak se používá. Pro lidi, jako jsem já, kteří narazí na tuto otázku, myslel jsem, že by bylo užitečné mít k dispozici odkaz na oficiální dokumentaci k získání a nastavení na webové stránce strojopisu as tím se to vysvětluje dobře, doufejme, že vždy zůstat up-to-date, jako jsou změny vyrobeny, a ukazuje příklad použití:

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

Zejména pro ty, kteří nejsou obeznámeni s tím, na vědomí, že nezahrnují slovo ‚dostat‘ do volání pohlcovač plynu (a podobně tvůrci):

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

Měli byste prostě to následujícím způsobem:

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

vzhledem k tomu, třída, jako jsou:

class foo {
  private _bar:boolean = false;

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

pak se bude nazývat ‚bar‘ kariérista pro soukromý ‚_bar‘ vlastnictví.

Zde je funkční příklad, který vám musí směřovat správným směrem:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getry a tvůrci v JavaScriptu jsou jen normální funkce. Vypalovací je funkce, která přebírá parametr, jehož hodnota je hodnota je nastavena.

Je velmi podobná vytváření společných metod, jednoduše řečeno klíčové slovo vyhrazené getnebo setna začátku.

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

V tomto případě můžete přeskočit typ návratu do get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Můžete napsat tento

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 poskytuje metody pro čtení a zápis, které umožňují vlastnosti objektu mít větší kontrolu nad tím jak jsou přístupné (getter) nebo aktualizovány (seřizovač) vně objektu. Namísto přímého přístupu nebo aktualizaci vlastnost funkce proxy nazývá.

Příklad:

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

Myslím, že asi jsem si, proč je to tak matoucí. Ve Vašem příkladu, chceme metody pro čtení a zápis pro _name. Ale my jsme toho dosáhnout vytvořením metody pro čtení a zápis k nepříbuzným třídní proměnné Name.

Zvaž toto:

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

Výše uvedený kód dělá následující:

1. geta setvytvoření mechanismů získání a nastavení pro yourCarTiresCount( netiresCount ).

Getr je:

function() {
    return this.tiresCount ;
}

a setr je:

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

Což znamená, pokaždé, když děláme new Car().yourCarTiresCount, kariérista běží. A za každých new Car().yourCarTiresCount('7')setter běhů.

2. Nepřímo vytvořit kariérista, ale nikoli setra pro soukromé tireCount.

Pokud pracujete s strojopisu moduly a snaží se přidat kariérista, který je exportován, můžete udělat něco takového:

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

Pak, v jiném souboru máte:

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