TypeScript में फ़ंक्शन

यह लेख TypeScript में फ़ंक्शंस को समझाता है।

YouTube Video

TypeScript में फ़ंक्शन

TypeScript में फ़ंक्शन, JavaScript के फ़ंक्शंस हैं जिनमें टाइप एनोटेशन जोड़े गए हैं। TypeScript में, आप इनपुट्स (पैरामीटर) और आउटपुट्स (रिटर्न वैल्यू) के प्रकारों को स्पष्ट रूप से परिभाषित करके अधिक मज़बूत कोड लिख सकते हैं। नीचे, हम फ़ंक्शंस को परिभाषित करने की मूलभूत विधियां और TypeScript में फ़ंक्शंस की कुछ विशेषताओं को प्रस्तुत कर रहे हैं।

मूलभूत फ़ंक्शन परिभाषा

1function add(x: number, y: number): number {
2    return x + y;
3}
4
5console.log(add(5, 10));  // 15

• ‘add’ फ़ंक्शन दो तर्क लेता है जो ‘number’ प्रकार के होते हैं और एक ‘number’ प्रकार का मान लौटाता है।
• यह दो तर्क लेता है, ‘x’ और ‘y’, दोनों ‘number’ प्रकार के होते हैं, और इनके प्रकार स्पष्ट रूप से निर्दिष्ट किए गए हैं।
• रिटर्न प्रकार भी ‘: number’ के रूप में निर्दिष्ट किया गया है।

अनाम फ़ंक्शन (फ़ंक्शन एक्सप्रेशन्स)

अनाम फ़ंक्शंस और फ़ंक्शन एक्सप्रेशन्स को TypeScript में भी इस्तेमाल किया जा सकता है। प्रकारों को उसी तरह से एनोटेट किया जा सकता है।

1const multiply = function (x: number, y: number): number {
2    return x * y;
3};
4
5console.log(multiply(3, 4));  // 12

• आप किसी बेनामी (anonymous) फ़ंक्शन को किसी वेरिएबल में असाइन कर सकते हैं और बाद में उसे कॉल कर सकते हैं।

1const factorial = function fact(n: number): number {
2  if (n <= 1) return 1;
3  return n * fact(n - 1); // Can call itself recursively
4};
5
6console.log(factorial(5)); // 120

• आप पुनरावर्ती (recursive) कॉल्स के लिए एक नामित फ़ंक्शन अभिव्यक्ति (named function expression) का उपयोग कर सकते हैं।

ऐरो फ़ंक्शंस

ऐरो फ़ंक्शंस के साथ भी टाइप एनोटेशन का उपयोग किया जा सकता है।

1const subtract = (x: number, y: number): number => {
2    return x - y;
3};
4
5console.log(subtract(10, 4));  // 6

यह कोड टाइप एनोटेशन के साथ एक ऐरो फ़ंक्शन ‘subtract’ को परिभाषित करता है, जो दो नंबर तर्क के रूप में लेता है और उनका अन्तर लौटाता है।

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

पैरामीटर को वैकल्पिक बनाया जा सकता है या डिफ़ॉल्ट मान दिए जा सकते हैं।

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

पैरामीटर नाम के बाद ? जोड़ने से यह वैकल्पिक बन जाता है।

1function greet(name?: string): string {
2    return name ? `Hello, ${name}` : "Hello!";
3}
4
5console.log(greet());        // Hello!
6console.log(greet("Alice"));  // Hello, Alice

यह कोड एक वैकल्पिक तर्क लेता है; अगर तर्क दिया गया है तो नाम के साथ अभिवादन करता है, अन्यथा सामान्य अभिवादन लौटाता है।

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

आप पैरामीटर्स के लिए डिफ़ॉल्ट मान भी सेट कर सकते हैं।

1function greetWithDefault(name: string = "Guest"): string {
2    return `Hello, ${name}`;
3}
4
5console.log(greetWithDefault());         // Hello, Guest
6console.log(greetWithDefault("Bob"));    // Hello, Bob

यह फ़ंक्शन ‘Guest’ को डिफ़ॉल्ट मान के रूप में उपयोग करता है अगर कोई तर्क नहीं दिया गया है, और दिए गए या डिफ़ॉल्ट नाम से अभिवादन करता है।

फ़ंक्शन प्रकार की परिभाषा

फ़ंक्शन के प्रकार को स्वयं परिभाषित करना भी संभव है। उदाहरण के लिए, यह तब उपयोग किया जाता है जब एक फ़ंक्शन को आर्ग्युमेंट के रूप में पास किया जाता है।

1type Operation = (x: number, y: number) => number;
2
3const addOperation: Operation = (x, y) => x + y;
4const multiplyOperation: Operation = (x, y) => x * y;
5
6console.log(addOperation(2, 3));      // 5
7console.log(multiplyOperation(2, 3)); // 6

यह कोड एक फ़ंक्शन प्रकार ‘Operation’ को परिभाषित करता है जो दो नंबर लेता है और एक नंबर लौटाता है, फिर इसके द्वारा जोड़ और गुणा के फ़ंक्शन बनाकर उन्हें चलाता है।

जब कोई रिटर्न वैल्यू नहीं होती है (void प्रकार)

जिन फंक्शन का कोई रिटर्न वैल्यू नहीं है, उनके लिए void टाइप निर्दिष्ट करें।

1function logMessage(message: string): void {
2    console.log(message);
3}
4
5logMessage("This is a message.");  // This is a message.

यह कोड एक ‘void’ फ़ंक्शन ‘logMessage’ को परिभाषित करता है जो एक स्ट्रिंग संदेश लेता है और उसे कंसोल पर प्रिंट करता है बिना कोई मान लौटाए।

कॉलबैक फ़ंक्शन

किसी फ़ंक्शन को दूसरे फ़ंक्शन के तर्क के रूप में पास करना और बाद में उसे निष्पादित करना कॉलबैक फ़ंक्शन कहलाता है। इसका अक्सर एसिंक्रोनस प्रोसेसिंग और इवेंट हैंडलिंग में उपयोग किया जाता है।

1function processData(callback: (data: string) => void): void {
2    const data: string = "Processed Data";
3    callback(data);
4}
5
6processData((result: string): void => {
7    console.log(result);
8});

इस उदाहरण में, एक फ़ंक्शन जो किसी मान को कंसोल में आउटपुट करता है, उसे कॉलबैक फ़ंक्शन के रूप में पास किया गया है।

वैकल्पिक रूप से, आप type या interface का उपयोग करके एक कॉलबैक टाइप भी परिभाषित कर सकते हैं।

 1type Callback = (data: string) => void;
 2
 3function processData(callback: Callback): void {
 4    const data: string = "Processed Data";
 5    callback(data);
 6}
 7
 8processData((result: string): void => {
 9    console.log(result);
10});

type या interface का उपयोग करके कॉलबैक टाइप परिभाषित करने से पुन: प्रयोज्यता (reusability) बेहतर होती है।

फंक्शन ओवरलोडिंग

फंक्शन ओवरलोडिंग आपको एक ही नाम के साथ लेकिन अलग-अलग पैरामीटर सूचियों वाले फंक्शनों को परिभाषित करने की अनुमति देती है। TypeScript में, आप एक ही नाम के साथ कई फंक्शन को परिभाषित कर सकते हैं और पैरामीटर के प्रकार और संख्या के आधार पर अलग-अलग ऑपरेशन कर सकते हैं।

 1// Overload Signature
 2function double(value: number): number;
 3function double(value: string): string;
 4
 5// Implementation Signature
 6function double(value: number | string): number | string {
 7    if (typeof value === "number") {
 8        return value * 2;
 9    } else if (typeof value === "string") {
10        return value + value;
11    }
12}
13
14console.log(double(10));      // 20
15console.log(double("Hello")); // HelloHello

TypeScript में, ओवरलोडिंग इस प्रकार प्राप्त की जाती है:।

• ओवरलोड सिग्नेचर

  • यह परिभाषित करता है कि फंक्शन का उपयोग कैसे किया जा सकता है (इसका सिग्नेचर)। इसे कई बार लिखकर, ओवरलोडिंग संभव हो जाती है।

• इम्प्लिमेंटेशन सिग्नेचर

  • वास्तविक फंक्शन बॉडी को लागू करता है। यह भाग केवल एक बार परिभाषित किया जाता है और ओवरलोड सिग्नेचर्स में घोषित सभी मामलों को संभालता है।

ओवरलोडिंग के लिए नियम

फंक्शन ओवरलोडिंग पर निम्नलिखित नियम लागू होते हैं:।

• ओवरलोड सिग्नेचर परिभाषाओं का क्रम

  • चूंकि मूल्यांकन ऊपर से नीचे तक होता है, इसलिए पहले विशिष्ट प्रकार को परिभाषित करना और उसके बाद सामान्य प्रकार को परिभाषित करना अनुशंसित है।

• इम्प्लिमेंटेशन सिग्नेचर की संगतता

  • कार्यान्वयन हस्ताक्षर को सभी ओवरलोड हस्ताक्षरों के तर्कों और वापसी मानों के साथ संगत होना चाहिए।

• ओवरलोड हस्ताक्षरों में विवरण निर्दिष्ट करें

  • कार्यान्वयन हस्ताक्षर अस्पष्ट हो सकता है, इसलिए विवरण ओवरलोड हस्ताक्षरों में निर्दिष्ट किया जाना चाहिए।
  • यदि केवल कार्यान्वयन हस्ताक्षर परिभाषित किया गया है, तो फ़ंक्शन के लिए प्रकार अनुमान अपर्याप्त होगा।

सारांश

TypeScript में फ़ंक्शन्स की निम्नलिखित विशेषताएँ होती हैं।

• टाइप एनोटेशन
  • आर्ग्युमेंट्स और रिटर्न वैल्यू के लिए टाइप्स निर्धारित करके, आप अधिक सुरक्षित कोड लिख सकते हैं।
• गुमनाम फ़ंक्शन्स और ऐरो फ़ंक्शन्स
  • इन्हें जावास्क्रिप्ट की तरह इस्तेमाल किया जा सकता है, और टाइप एनोटेशन जोड़ने से टाइप सुरक्षा बेहतर होती है।
• वैकल्पिक और डिफ़ॉल्ट पैरामीटर्स
  • आप आवश्यकता अनुसार आर्ग्युमेंट स्पेसिफिकेशन को अधिक लचीला बना सकते हैं।
• फ़ंक्शन टाइप परिभाषाएँ
  • टाइप चेकिंग करने के लिए स्वयं फ़ंक्शन की टाइप निर्धारित करें।
• फ़ंक्शन ओवरलोडिंग
  • आप एक ही फ़ंक्शन नाम के साथ अलग-अलग आर्ग्युमेंट्स का समर्थन कर सकते हैं।

इनका उपयोग करके, आप TypeScript में अधिक स्पष्ट और मजबूत कोड लिख सकते हैं।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video