erhalten und setzen in Typoskript

Ezward hat bereits eine gute Antwort, aber ich bemerkte, dass einer der Kommentare fragt, wie es verwendet wird. Für Leute wie mich, die über diese Frage stolpern, dachte ich, es wäre nützlich, einen Link zu der offiziellen Dokumentation auf Getter und Setter auf der Typoskript Website zu haben als dass es gut erklärt, wird hoffentlich immer bleiben up-to-date wie Änderungen gemacht, und zeigt Beispiel Nutzung:

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

Insbesondere für diejenigen, nicht mit ihm vertraut, beachten Sie, dass Sie ‚get‘ in einen Aufruf an ein Getter (und ähnlich für Setter) nicht das Wort übernehmen:

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

Sie sollten dies einfach tun:

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

gegeben eine Klasse wie:

class foo {
  private _bar:boolean = false;

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

dann werden die ‚Bar‘ Getter für das private '_bar Eigentum genannt werden.

Hier ist ein funktionierendes Beispiel, dass Sie in der richtigen Richtung zeigen soll:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getter und Setter in JavaScript sind nur ganz normale Funktionen. Der Setter ist eine Funktion, die einen Parameter, dessen Wert annimmt, ist der Wert eingestellt wird.

Es ist sehr ähnlich zu herkömmlichen Methoden erstellen, einfach das reservierten Schlüsselwort setzen getoder setam Anfang.

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 diesem Fall können Sie den Rückgabetyp überspringen in get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Sie können dies schreiben

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 bietet Getter und Setter , die Objekteigenschaften ermöglichen eine bessere Kontrolle zu haben , wie auf sie zugegriffen wird (Getter) oder aktualisiert (Setter) außerhalb des Objekts. Anstatt direkt zugreifen oder die Eigenschaft eine Proxy - Funktion aufgerufen wird , zu aktualisieren.

Beispiel:

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

Ich glaube , ich wahrscheinlich bekommen , warum ist es so verwirrend. In Ihrem Beispiel wollten wir Getter und Setter für _name. Aber wir das erreichen von Getter und Setter für einen unabhängigen Klassenvariable zu schaffen Name.

Bedenken Sie:

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

Obiger Code funktioniert folgendermaßen vor:

1. getund seterstellen Getter und Setter für yourCarTiresCount( nichttiresCount ).

Der Getter ist:

function() {
    return this.tiresCount ;
}

und die Setter ist:

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

Das heißt, jedes Mal , wenn wir tun new Car().yourCarTiresCount, Getter läuft. Und für jeden new Car().yourCarTiresCount('7')Setter läuft.

2. Indirekt erstellen Getter, aber nicht die Setter, für private tireCount.

Wenn Sie mit Typoskript Module arbeiten und versuchen, einen Getter hinzuzufügen, die exportiert wird, können Sie etwas tun, wie folgt:

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

Dann in einer anderen Datei, die Sie haben:

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