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

जावास्क्रिप्ट में कार्यात्मक प्रोग्रामिंग: सिद्धांत से Node.js पर व्यवहार तक

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

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

उन्नत स्तर पर, केवल शुद्ध फलन की परिभाषा जानना पर्याप्त नहीं है। यह समझना महत्वपूर्ण है कि अपरिवर्तनीयता और दुष्प्रभावों की अनुपस्थिति एप्लिकेशन आर्किटेक्चर को कैसे प्रभावित करती है, विशेष रूप से Node.js वातावरण में, जहाँ अक्सर समवर्ती संचालन का उपयोग किया जाता है।

1.1. गहरी प्रतिलिपि और संरचनात्मक साझाकरण (Structural Sharing)

बड़ी वस्तुओं की पूर्ण गहरी प्रतिलिपि महंगी हो सकती है। इसके बजाय, Immer या Immutable.js जैसी लाइब्रेरीज़ संरचनात्मक साझाकरण का उपयोग करती हैं: किसी वस्तु के भाग को बदलने पर एक नया संदर्भ बनाया जाता है, लेकिन अपरिवर्तित भाग पिछली स्थिति के साथ साझा किए जाते हैं।

// Immer (लोकप्रिय लाइब्रेरी) का उपयोग करके उदाहरणconst { produce } = require('immer');

const baseState = {  user: { name: 'Alice', age: 30 },  meta: { created: Date.now() }};

// produce baseState को म्यूट किए बिना एक नई स्थिति बनाता हैconst nextState = produce(baseState, draft => {  draft.user.age = 31;});

console.log(baseState.user.age); // 30console.log(nextState.user.age); // 31console.log(baseState.meta === nextState.meta); // true (संरचनात्मक साझाकरण)

1.2. शुद्ध फलन और मेमोइज़ेशन

शुद्ध फलन मेमोइज़ेशन के लिए आदर्श हैं - बार-बार गणना को रोकने के लिए परिणामों को कैश करना। Node.js में, यह भारी गणना या डेटाबेस क्वेरी के लिए महत्वपूर्ण है।

// शुद्ध फलन के लिए सरल मेमोइज़ेशनconst memoize = (fn) => {  const cache = new Map();  return (...args) => {    const key = JSON.stringify(args);    if (cache.has(key)) {      console.log('कैश से');      return cache.get(key);    }    const result = fn(...args);    cache.set(key, result);    return result;  };};

const fibonacci = (n) => (n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2));const memoizedFib = memoize(fibonacci);

console.log(memoizedFib(40)); // गणना की जाती हैconsole.log(memoizedFib(40)); // कैश से

2. फलन संरचना: सरल से जटिल का निर्माण

संरचना दो या अधिक फलनों को मिलाकर एक नया फलन प्राप्त करने की प्रक्रिया है। उन्नत स्तर पर, हम न केवल सरल संरचना का उपयोग करते हैं, बल्कि Pipe और Compose जैसे पैटर्न का भी उपयोग करते हैं, जो डेटा प्रोसेसिंग पाइपलाइनों के निर्माण का आधार हैं।

2.1. Pipe और Compose

Pipe फलनों को बाएँ से दाएँ निष्पादित करता है, जबकि Compose दाएँ से बाएँ। Node.js में, इसका उपयोग अक्सर इनकमिंग डेटा (जैसे, HTTP अनुरोध) को संसाधित करने के लिए किया जाता है।

// pipe का कार्यान्वयनconst pipe = (...fns) => (x) => fns.reduce((acc, fn) => fn(acc), x);

// उदाहरण: स्ट्रिंग प्रसंस्करणconst toLowerCase = (str) => str.toLowerCase();const removeSpaces = (str) => str.replace(/\\s+/g, '-');const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

const slugify = pipe(toLowerCase, removeSpaces, capitalize);console.log(slugify('Hello World From Node.js')); // Hello-world-from-node.js

2.2. अतुल्यकालिक पाइपलाइन

वास्तविक Node.js अनुप्रयोगों में, फलन अक्सर अतुल्यकालिक होते हैं। आइए प्रॉमिस के साथ काम करने के लिए pipe का एक संस्करण बनाएँ।

const asyncPipe = (...fns) => (x) =>  fns.reduce((acc, fn) => acc.then(fn), Pr