TypeScript
कार्य

टिप्पणियों

वैकल्पिक और डिफ़ॉल्ट पैरामीटर

वैकल्पिक पैरामीटर

टाइपस्क्रिप्ट में, प्रत्येक पैरामीटर को फ़ंक्शन द्वारा आवश्यक माना जाता है। आप एक जोड़ सकते हैं ? इसे वैकल्पिक के रूप में सेट करने के लिए एक पैरामीटर नाम के अंत में।

उदाहरण के लिए, lastName इस समारोह के पैरामीटर वैकल्पिक है:

function buildName(firstName: string, lastName?: string) {
    // ...
}

वैकल्पिक पैरामीटर सभी गैर-वैकल्पिक मापदंडों के बाद आने चाहिए:

function buildName(firstName?: string, lastName: string) // Invalid

डिफ़ॉल्ट पैरामीटर

यदि उपयोगकर्ता undefined गुजरता है या तर्क निर्दिष्ट नहीं करता है, तो डिफ़ॉल्ट मान असाइन किया जाएगा। इन्हें डिफ़ॉल्ट-आरंभिक पैरामीटर कहा जाता है।

उदाहरण के लिए, "स्मिथ" के लिए डिफ़ॉल्ट मान है lastName पैरामीटर।

function buildName(firstName: string, lastName = "Smith") {
    // ...
}
buildName('foo', 'bar');      // firstName == 'foo', lastName == 'bar'
buildName('foo');             // firstName == 'foo', lastName == 'Smith'
buildName('foo', undefined);  // firstName == 'foo', lastName == 'Smith'

प्रकार के कार्य

नामित कार्य

function multiply(a, b) {
    return a * b;
}

अनाम कार्य

let multiply = function(a, b) { return a * b; };

लैम्ब्डा / एरो फ़ंक्शंस

let multiply = (a, b) => { return a * b; };

एक पैरामीटर के रूप में कार्य

मान लें कि हम एक पैरामीटर के रूप में एक फ़ंक्शन प्राप्त करना चाहते हैं, हम इसे इस तरह से कर सकते हैं:

function foo(otherFunc: Function): void {
    ...
}

अगर हम एक निर्माता को एक पैरामीटर के रूप में प्राप्त करना चाहते हैं:

function foo(constructorFunc: { new() }) {
    new constructorFunc();
}

function foo(constructorWithParamsFunc: { new(num: number) }) {
    new constructorWithParamsFunc(1);
}

या इसे पढ़ने में आसान बनाने के लिए हम कंस्ट्रक्टर का वर्णन करने वाले इंटरफ़ेस को परिभाषित कर सकते हैं:

interface IConstructor {
    new();
}

function foo(contructorFunc: IConstructor) { 
    new constructorFunc();
}

या मापदंडों के साथ:

interface INumberConstructor {
    new(num: number);
}

function foo(contructorFunc: INumberConstructor) {
    new contructorFunc(1);
}

जेनरिक के साथ भी:

interface ITConstructor<T, U> {
    new(item: T): U;
}

function foo<T, U>(contructorFunc: ITConstructor<T, U>, item: T): U {
    return new contructorFunc(item);
}

यदि हम एक साधारण फ़ंक्शन प्राप्त करना चाहते हैं और एक निर्माता नहीं है तो यह लगभग समान है:

function foo(func: { (): void }) {
    func();
}

function foo(constructorWithParamsFunc: { (num: number): void }) {
    new constructorWithParamsFunc(1);
}

या इसे पढ़ने में आसान बनाने के लिए हम फ़ंक्शन का वर्णन करने वाले इंटरफ़ेस को परिभाषित कर सकते हैं:

interface IFunction {
    (): void;
}

function foo(func: IFunction ) { 
    func();
}

या मापदंडों के साथ:

interface INumberFunction {
    (num: number): string;
}

function foo(func: INumberFunction ) {
    func(1);
}

जेनरिक के साथ भी:

interface ITFunc<T, U> {
    (item: T): U;
}

function foo<T, U>(contructorFunc: ITFunc<T, U>, item: T): U {
    return func(item);
}

संघ प्रकार के साथ कार्य

एक टाइपस्क्रिप्ट फ़ंक्शन यूनियन प्रकारों का उपयोग करके कई, पूर्वनिर्धारित प्रकारों के मापदंडों में ले जा सकता है।

function whatTime(hour:number|string, minute:number|string):string{
    return hour+':'+minute;
}

whatTime(1,30)         //'1:30'
whatTime('1',30)       //'1:30'
whatTime(1,'30')       //'1:30'
whatTime('1','30')     //'1:30'

टाइपस्क्रिप्ट इन मापदंडों को एक प्रकार का मानते हैं जो अन्य प्रकारों का एक संघ है, इसलिए आपका कार्य किसी भी प्रकार के मापदंडों को संभालने में सक्षम होना चाहिए जो संघ में है।

function addTen(start:number|string):number{
    if(typeof number === 'string'){
        return parseInt(number)+10;
    }else{
        else return number+10;
    }
}