जावास्क्रिप्ट में शुद्ध कार्य क्या हैं?

शुद्ध कार्य कार्यात्मक प्रोग्रामिंग में बिल्डिंग ब्लॉक हैं। वे सादगी और परीक्षणशीलता के लिए प्रशंसित हैं।

इस लेख में, आपको एक चेकलिस्ट मिलेगी जो यह निर्धारित करने में मदद करेगी कि कोई फ़ंक्शन शुद्ध है या नहीं।

सूची की जाँच करें

एक फ़ंक्शन को "शुद्ध" माना जाने के लिए दो शर्तों को पूरा करना चाहिए:

- हर बार फ़ंक्शन उसी परिणाम को लौटाता है जब उसे उसी तर्क के सेट के साथ कहा जाता है

- कोई साइड इफेक्ट नहीं

आइए अधिक विस्तार से विचार करें।

1. एक ही इनपुट => एक ही आउटपुट

इसकी तुलना करें:

const add = (x, y) => x + y; add(2, 4); // 6 

इसके साथ:

 let x = 2; const add = (y) => { x += y; }; add(4); // x === 6 (the first time) 

पहले मामले में, मान निर्दिष्ट मापदंडों के आधार पर लौटाया जाता है, जहां आप इसे कहते हैं / जहां की परवाह किए बिना।

यदि आप 2 और 4 जोड़ते हैं, तो आपको हमेशा 6 मिलते हैं।

कुछ भी परिणाम को प्रभावित नहीं करता है।

प्रभाव कार्य = असंगत परिणाम

दूसरा उदाहरण कुछ नहीं देता है। वह अपने क्षेत्र के बाहर चर को बढ़ाकर अपने काम को करने के लिए सामान्य स्थिति पर निर्भर करता है।

यह मॉडल डेवलपर्स के लिए एक बुरा सपना है।

साझा स्थिति एक समय निर्भरता का परिचय देती है। जब आप फ़ंक्शन को कॉल करते हैं तो आपको अलग-अलग परिणाम मिलते हैं। पहली बार परिणाम 6, अगली बार 10 और इसी तरह।

कौन सा बेहतर है?

किस मामले में आपको कुछ कीड़े मिलेंगे जो केवल कुछ शर्तों के तहत दिखाई देते हैं?

किस मामले में आप बहु-थ्रेडेड वातावरण में सफल होने की संभावना रखते हैं जहां समय निर्भरता प्रणाली को तोड़ सकती है?

निश्चित रूप से पहले में।

2. कोई साइड इफेक्ट नहीं

यह परीक्षण अपने आप में एक चेकलिस्ट है।

दुष्प्रभावों के उदाहरण:

1. इनपुट मापदंडों का संशोधन
2. console.log
3. HTTP कॉल (AJAX / fetch)
4. फ़ाइल सिस्टम परिवर्तन
5. डोम अनुरोध

वास्तव में, किसी फ़ंक्शन द्वारा निष्पादित कोई भी कार्य अंतिम परिणाम की गणना से संबंधित नहीं है।

मैं आपको बॉब मार्टिन का वीडियो देखने की सलाह देता हूं।

एक साइड इफेक्ट के साथ एक "गंदा" फ़ंक्शन है।

 const impureDouble = (x) => { console.log('doubling', x); return x * 2; }; const result = impureDouble(4); console.log({ result }); 

कंसोल.लॉग यहां एक साइड इफेक्ट है, लेकिन यह चोट नहीं पहुंचाएगा। हम अभी भी वही परिणाम प्राप्त करेंगे, जो समान डेटा है।

हालांकि, यह समस्याएं पैदा कर सकता है।

"प्रभाव" वस्तु परिवर्तन

 const impureAssoc = (key, value, object) => { object[key] = value; }; const person = { name: 'Bobo' }; const result = impureAssoc('shoeSize', 400, person); console.log({ person, result }); 

व्यक्ति चर को हमेशा के लिए बदल दिया गया क्योंकि फ़ंक्शन को असाइनमेंट स्टेटमेंट के जरिए घोषित किया गया था।

साझा स्थिति का अर्थ है कि impureAssoc का प्रभाव अब पूरी तरह से स्पष्ट नहीं है। सिस्टम पर प्रभाव को समझने में अब हर चर को ट्रैक करना शामिल है जिसे उसने कभी भी छुआ है और उसके इतिहास को जानता है।

साझा स्थिति = समय निर्भरता।

हम केवल वांछित गुणों के साथ एक नई वस्तु वापस करके impureAssoc को साफ कर सकते हैं।

"हम इसे साफ करते हैं"

 const pureAssoc = (key, value, object) => ({ ...object, [key]: value }); const person = { name: 'Bobo' }; const result = pureAssoc('shoeSize', 400, person); console.log({ person, result }); 

PureAssoc अब परीक्षा परिणाम लौटाता है, इसलिए यदि यह कहीं और बदल जाए तो आपको चिंता करने की ज़रूरत नहीं है।

यह इस तरह किया जा सकता है:

 const pureAssoc = (key, value, object) => { const newObject = { ...object }; newObject[key] = value; return newObject; }; const person = { name: 'Bobo' }; const result = pureAssoc('shoeSize', 400, person); console.log({ person, result }); 

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

परिवर्तन इस छोटे से क्षेत्र तक सीमित हैं, और आप अभी भी मान लौटा रहे हैं।

सारांश

• एक फ़ंक्शन शुद्ध होता है अगर इसका कोई साइड इफेक्ट नहीं होता है और हर बार उसी परिणाम को लौटाता है जब इसे तर्कों के एक ही सेट के साथ कहा जाता है।
• साइड इफेक्ट्स में शामिल हैं: इनपुट बदलना, HTTP कॉल, डिस्क पर लिखना, स्क्रीन पर आउटपुट।
• आप सुरक्षित रूप से क्लोन कर सकते हैं और फिर इनपुट मापदंडों को बदल सकते हैं। बस मूल अपरिवर्तित छोड़ दें।
• वितरण सिंटैक्स (... सिंटैक्स) ऑब्जेक्ट और सरणियों को क्लोन करने का सबसे आसान तरीका है।