TypeScript में कार्यात्मक प्रोग्रामिंग: मूल बातें और अभ्यास

TypeScript में कार्यात्मक प्रोग्रामिंग: सिद्धांत से व्यवहार तक

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

1. शुद्ध फ़ंक्शन और अपरिवर्तनीयता

शुद्ध फ़ंक्शन वह फ़ंक्शन है जो:

• समान तर्कों के लिए हमेशा समान परिणाम लौटाता है (नियतिवाद)।
• इसका कोई दुष्प्रभाव नहीं होता (बाहरी चर को नहीं बदलता, डेटा आउटपुट नहीं करता, अनुरोध नहीं करता)।

शुद्ध फ़ंक्शन का उदाहरण:

// शुद्ध फ़ंक्शन: दो संख्याओं का योग करता हैconst add = (a: number, b: number): number => a + b;

// हमेशा 5 लौटाएगाconsole.log(add(2, 3)); // 5console.log(add(2, 3)); // 5

अपरिवर्तनीयता वह सिद्धांत है जिसके तहत डेटा बनने के बाद उसे बदला नहीं जाता। मौजूदा ऑब्जेक्ट को बदलने के बजाय एक नया ऑब्जेक्ट बनाया जाता है।

// ऐरे का अपरिवर्तनीय अद्यतनconst numbers: number[] = [1, 2, 3];

// बुरा (उत्परिवर्तन):numbers.push(4);

// अच्छा (अपरिवर्तनीय):const newNumbers = [...numbers, 4]; // [1,2,3,4]

// ऑब्जेक्ट का अपरिवर्तनीय अद्यतनinterface User {  name: string;  age: number;}

const user: User = { name: 'Alice', age: 30 };const updatedUser: User = { ...user, age: 31 }; // नया ऑब्जेक्ट

2. फ़ंक्शन संयोजन और करीइंग

फ़ंक्शन संयोजन दो या अधिक फ़ंक्शनों को एक नए फ़ंक्शन में संयोजित करना है। पहले फ़ंक्शन का परिणाम दूसरे फ़ंक्शन के तर्क के रूप में पारित किया जाता है।

// दो फ़ंक्शनों का संयोजनconst compose = <T, U, V>(f: (x: U) => V, g: (x: T) => U) =>  (x: T): V => f(g(x));

const double = (x: number): number => x * 2;const increment = (x: number): number => x + 1;

const doubleThenIncrement = compose(increment, double);console.log(doubleThenIncrement(3)); // (3*2)+1 = 7

करीइंग कई तर्कों वाले फ़ंक्शन को एक तर्क वाले फ़ंक्शनों के अनुक्रम में बदलना है।

// सामान्य फ़ंक्शनconst multiply = (a: number, b: number): number => a * b;

// करीड संस्करणconst curriedMultiply = (a: number) => (b: number): number => a * b;

const multiplyBy2 = curriedMultiply(2);console.log(multiplyBy2(5)); // 10console.log(multiplyBy2(7)); // 14

करीइंग आंशिक अनुप्रयोग और फ़ंक्शनों के पुन: उपयोग को सरल बनाता है।

3. फंक्टर और मोनैड: Maybe और Either

फंक्टर एक कंटेनर है जो map विधि को लागू करता है, जो कंटेनर के अंदर मान पर फ़ंक्शन लागू करने की अनुमति देता है। TypeScript में, उदाहरण के लिए, ऐरे एक फंक्टर है:

const numbers = [1, 2, 3];const doubled = numbers.map(x => x * 2); // [2, 4, 6]

मोनैड एक फंक्टर है जो अतिरिक्त रूप से flatMap (या bind) और of (या return) विधियों को लागू करता है। मोनैड अपवादों के बिना दुष्प्रभावों, null-मानों और त्रुटियों को संभालने में मदद करते हैं।

हम null/undefined के साथ सुरक्षित रूप से काम करने के लिए एक सरल Maybe मोनैड लागू करते हैं:

// Maybe मोनैडclass Maybe<T> {  private constructor(private value: T | null) {}

  static of<T>(value: T): Maybe<T> {    return new Maybe(value);  }

  static none<T>(): Maybe<T> {    return new Maybe<T>(null);  }

  map<U>(fn: (value: T) => U): Maybe<U> {    if (this.value === null || this.value === undefined) {      return Maybe.none();    }    return M