TypeScript में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

TypeScript में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

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

1. अपरिवर्तनीयता और संरचनात्मक साझाकरण

अपरिवर्तनीयता FP की आधारशिला है। TypeScript में, हम readonly और ReadonlyArray की मदद से प्रकार स्तर पर अपरिवर्तनीयता सुनिश्चित कर सकते हैं। हालाँकि, बड़ी डेटा संरचनाओं (जैसे Redux store) के साथ कुशलतापूर्वक काम करने के लिए, संरचनात्मक साझाकरण का उपयोग किया जाता है - Immer या Immutable.js जैसी लाइब्रेरी।

readonly और बिना उत्परिवर्तन के नेस्टेड ऑब्जेक्ट को अपडेट करने के फ़ंक्शन का उपयोग करने का एक उदाहरण देखें:

type User = {  readonly id: number;  readonly name: string;  readonly address: {    readonly city: string;    readonly zip: string;  };};

const updateUserCity = (user: User, newCity: string): User => ({  ...user,  address: {    ...user.address,    city: newCity,  },});

const user: User = { id: 1, name: 'Alice', address: { city: 'NYC', zip: '10001' } };const updatedUser = updateUserCity(user, 'LA');console.log(user.address.city); // NYC (मूल नहीं बदला)console.log(updatedUser.address.city); // LA

ध्यान दें: हम एक नया ऑब्जेक्ट बना रहे हैं, लेकिन अपरिवर्तित भागों (जैसे id और name) का पुन: उपयोग कर रहे हैं। यह मैन्युअल रूप से संरचनात्मक साझाकरण है। गहरी नेस्टिंग के लिए, लाइब्रेरी का उपयोग करना बेहतर है।

2. फंक्टर और उनका कार्यान्वयन

फंक्टर एक कंटेनर है जो map विधि को लागू करता है, जो कंटेनर की संरचना को बाधित किए बिना उसकी सामग्री पर एक फ़ंक्शन लागू करने की अनुमति देता है। TypeScript में, एक विशिष्ट फंक्टर Array है। लेकिन हम अपना स्वयं का फंक्टर बना सकते हैं, उदाहरण के लिए Maybe, null और undefined के साथ त्रुटियों से बचने के लिए।

हम एक सरल Maybe फंक्टर लागू करते हैं:

class Maybe<T> {  private constructor(private value: T | null) {}

  static of<U>(val: U | null | undefined): Maybe<U> {    return new Maybe(val ?? null);  }

  map<U>(fn: (val: T) => U): Maybe<U> {    if (this.value === null) {      return Maybe.of<U>(null);    }    return Maybe.of(fn(this.value));  }

  getOrElse(defaultValue: T): T {    return this.value !== null ? this.value : defaultValue;  }}

// उपयोगconst result = Maybe.of('hello')  .map(s => s.toUpperCase())  .map(s => s + ' world')  .getOrElse('fallback');console.log(result); // "HELLO WORLD"

const empty = Maybe.of<string>(null)  .map(s => s.toUpperCase())  .getOrElse('default');console.log(empty); // "default"

Maybe फंक्टर null की चिंता किए बिना सुरक्षित रूप से फ़ंक्शन को श्रृंखलाबद्ध रूप से कॉल करने की अनुमति देता है। प्रत्येक map एक नया Maybe लौटाता है, संदर्भ को बनाए रखता है।

3. मोनैड: साइड इफेक्ट के साथ संचालन की श्रृंखला

मोनैड एक फंक्टर है जो flatMap विधि (जिसे अक्सर bind या chain कहा जाता है) को भी लागू करता है। यह नेस्टेड कंटेनरों को "अनरैप" करने की अनुमति देता है। मोनैड का एक उत्कृष्ट उदाहरण Promise या Array है। अपवादों के बिना त्रुटि प्रबंधन के लिए Either मोनैड पर विचार करें।

type Either<L, R> = Left<L> | Right<R>;

class Left<L> {  readonly value: L;  constructor(value: L) { this.value = value; }  isLeft(): this is Left<L> { return true; }  isRight(): this is Right<ne