हो और टाइपप्रति में सेट

Ezward पहले से ही एक अच्छा जवाब प्रदान की गई है, लेकिन मैंने देखा है टिप्पणियों में से एक पूछता है कि यह कैसे किया जाता है। मेरे जैसे लोग हैं, जो इस सवाल को भूल गए हैं, तो मैंने सोचा कि यह के रूप में है कि यह अच्छी तरह से बताते हैं getters और टाइपप्रति वेबसाइट पर setters पर आधिकारिक दस्तावेज के लिए एक लिंक के लिए उपयोगी होगी, उम्मीद है कि हमेशा रहेगी अप करने की तारीख के रूप में परिवर्तन कर रहे हैं बनाया है, और उपयोग का उदाहरण दिखाता है:

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

विशेष रूप से, यह से परिचित नहीं उन लोगों के लिए, ध्यान दें कि आप शब्द 'के लिए' एक फोन में एक गेटर के लिए (setters के लिए और इसी तरह) को शामिल नहीं करते:

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

आप आसानी से इस करना चाहिए:

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

एक वर्ग की तरह दिया:

class foo {
  private _bar:boolean = false;

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

तो निजी '_bar' संपत्ति के लिए 'बार' गेटर बुलाया जाएगा।

यहाँ एक काम कर उदाहरण है कि आप सही दिशा में बात कर सकता है:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getters और जावास्क्रिप्ट में setters बस सामान्य कार्य हैं। सेटर एक समारोह है कि एक पैरामीटर जिसका मूल्य मूल्य स्थापित किया जा रहा है लेता है।

यह बहुत ही सामान्य तरीके बनाने के समान है, केवल कीवर्ड सुरक्षित रखा getया setशुरुआत में।

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

इस मामले में आप में वापसी प्रकार को छोड़ सकते हैं get getMethod1() {

    get getMethod1() {
        return this._name;
    }

आप यह लिख सकते हैं

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

}

टीएस getters और setters जो वस्तु गुण कैसे वे (गेटर) या अद्यतन (सेटर) एक्सेस किया जाता है और अधिक नियंत्रण के लिए अनुमति देते प्रदान करता है बाहर वस्तु की। इसके बजाय सीधे तक पहुँचने या संपत्ति एक प्रॉक्सी समारोह कहा जाता है को अद्यतन करने।

उदाहरण:

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

मुझे लगता है कि यही कारण है कि यह इतना भ्रामक है मैं शायद मिलता है। अपने उदाहरण में, हम के लिए getters और setters चाहता था _name। लेकिन हम एक असंबंधित वर्ग चर के लिए getters और setters बनाने के द्वारा प्राप्त Name।

इस पर विचार करो:

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

ऊपर कोड निम्नलिखित है:

1. getऔर setके लिए गेटर और सेटर बनाने yourCarTiresCount( नहीं करने के लिएtiresCount )।

गेटर है:

function() {
    return this.tiresCount ;
}

और सेटर है:

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

मतलब, हर बार जब हम करते हैं new Car().yourCarTiresCount, गेटर चलाता है। और हर के लिए new Car().yourCarTiresCount('7')सेटर चलाता है।

2. परोक्ष रूप से गेटर बनाने के लिए, लेकिन नहीं सेटर, निजी के लिए tireCount।

आप टाइपप्रति मॉड्यूल के साथ काम कर रहे हैं और एक गेटर कि निर्यात किया जाता है जोड़ने की कोशिश कर रहे हैं, तो आप कुछ इस तरह कर सकते हैं:

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

फिर, एक और फाइल में आप:

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