रामदा स्टाइल थिंकिंग: इम्यूटेबिलिटी एंड ऑब्जेक्ट्स

1. पहला कदम
2. कार्यों को मिलाएं
3. आंशिक उपयोग (करी)
4. घोषणात्मक प्रोग्रामिंग
5. क्वेंटेसिव नोटेशन
6. अपरिहार्यता और वस्तुएँ
7. अपरिहार्यता और सरणियाँ
8. लेंस
9. निष्कर्ष

यह पोस्ट कार्यात्मक प्रोग्रामिंग पर लेख की एक श्रृंखला का छठा हिस्सा है जिसे रामदा स्टाइल थिंकिंग कहा जाता है।

पांचवें भाग में, हमने व्यर्थ अंकन की शैली में लेखन कार्यों के बारे में बात की, जहां हमारे फ़ंक्शन के डेटा के साथ मुख्य तर्क स्पष्ट रूप से निर्दिष्ट नहीं है।

उस समय, हम अपने सभी कार्यों को एक बेबाक शैली में नहीं लिख सकते थे, क्योंकि हमारे पास इसके लिए आवश्यक कुछ उपकरण नहीं थे। यह उनका अध्ययन करने का समय है।

वस्तु गुण पढ़ना

आइए एक बार फिर उन लोगों की परिभाषा का उदाहरण देखें जिनके पास मतदान का अधिकार है, जिनकी हमने पांचवें भाग में जांच की थी:

const wasBornInCountry = person => person.birthCountry === OUR_COUNTRY const wasNaturalized = person => Boolean(person.naturalizationDate) const isOver18 = person => person.age >= 18 const isCitizen = either(wasBornInCountry, wasNaturalized) const isEligibleToVote = both(isOver18, isCitizen) 

जैसा कि आप देख सकते हैं, हमने बनाया isCitizen और isEligibleToVote , लेकिन हम पहले तीन कार्यों के साथ ऐसा नहीं कर सकते।

जैसा कि हमने चौथे भाग में सीखा, हम अपने कार्यों को समान और gte के उपयोग के माध्यम से अधिक घोषित कर सकते हैं। आइए इसकी शुरुआत करें:

 const wasBornInCountry = person => equals(person.birthCountry, OUR_COUNTRY) const wasNaturalized = person => Boolean(person.naturalizationDate) const isOver18 = person => gte(person.age, 18) 

इन कार्यों को व्यर्थ करने के लिए, हमें फ़ंक्शन के निर्माण का एक तरीका चाहिए ताकि हम अभिव्यक्ति के अंत में person चर को लागू करें। समस्या यह है कि हमें person के गुणों का उपयोग करने की आवश्यकता है, अब हम ऐसा करने का एकमात्र तरीका जानते हैं - और यह जरूरी है।

प्रोप

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

prop का उपयोग करके, हम person.birthCountry को prop('birthCountry', person) को फिर से person.birthCountry सकते हैं। चलो इसे करते हैं:

 const wasBornInCountry = person => equals(prop('birthCountry', person), OUR_COUNTRY) const wasNaturalized = person => Boolean(prop('naturalizationDate', person)) const isOver18 = person => gte(prop('age', person), 18) 

वाह, अब तो बहुत बुरा लग रहा है। लेकिन चलो हमारे refactoring जारी रखें। आइए हम उन तर्कों के क्रम को बदल दें जिन्हें हम equals ताकि prop अंतिम रहे। equals उल्टे तरीके से काम करता है, इसलिए हम कुछ भी नहीं तोड़ सकते हैं:

 const wasBornInCountry = person => equals(OUR_COUNTRY, prop('birthCountry', person)) const wasNaturalized = person => Boolean(prop('naturalizationDate', person)) const isOver18 = person => gte(prop('age', person), 18) 

अगला, आइए करीकरण का उपयोग करें, equals और gte की प्राकृतिक संपत्ति, नए कार्यों को बनाने के लिए जिसमें prop कॉल का परिणाम लागू होगा:

 const wasBornInCountry = person => equals(OUR_COUNTRY)(prop('birthCountry', person)) const wasNaturalized = person => Boolean(prop('naturalizationDate', person)) const isOver18 = person => gte(__, 18)(prop('age', person)) 

यह अभी भी सबसे खराब विकल्प की तरह दिखता है, लेकिन फिर भी हम इसे जारी रखते हैं। चलिए फिर से सभी prop कॉल के लिए करीने का लाभ लें:

 const wasBornInCountry = person => equals(OUR_COUNTRY)(prop('birthCountry')(person)) const wasNaturalized = person => Boolean(prop('naturalizationDate')(person)) const isOver18 = person => gte(__, 18)(prop('age')(person)) 

फिर, किसी तरह बहुत नहीं। लेकिन अब हम एक परिचित पैटर्न देखते हैं। हमारे सभी कार्यों में समान छवि f(g(person)) , और जैसा कि हम दूसरे भाग से जानते हैं, यह compose(f, g)(person) बराबर है।

आइए इस लाभ को हमारे कोड पर लागू करें:

 const wasBornInCountry = person => compose(equals(OUR_COUNTRY), prop('birthCountry'))(person) const wasNaturalized = person => compose(Boolean, prop('naturalizationDate'))(person) const isOver18 = person => compose(gte(__, 18), prop('age'))(person) 

अब हमें कुछ मिला। हमारे सभी कार्य person => f(person) तरह दिखते हैं। और हम पहले से ही पांचवें भाग से जानते हैं कि हम इन कार्यों को व्यर्थ कर सकते हैं।

 const wasBornInCountry = compose(equals(OUR_COUNTRY), prop('birthCountry')) const wasNaturalized = compose(Boolean, prop('naturalizationDate')) const isOver18 = compose(gte(__, 18), prop('age')) 

जब हमने शुरुआत की, तो यह स्पष्ट नहीं था कि हमारे तरीकों ने दो काम किए। उन्होंने ऑब्जेक्ट की संपत्ति की ओर रुख किया और इसके मूल्य के साथ कुछ ऑपरेशन तैयार किए। एक निरर्थक शैली में इस refactoring ने इसे बहुत स्पष्ट बना दिया।

आइए नज़र डालते हैं कुछ ऐसे ही अन्य साधनों पर, जिन्हें रामदा वस्तुओं के साथ काम करने के लिए प्रदान करता है।

चुनना

जहां prop किसी वस्तु की एक संपत्ति को पढ़ता है और उसका मूल्य लौटाता है, वहां से कई गुणों को पढ़ता है और केवल उनके साथ एक नई वस्तु लौटाता है।

उदाहरण के लिए, यदि हमें केवल व्यक्तियों के नाम और वर्षों की आवश्यकता है, तो हम pick(['name','age'], person) उपयोग कर सकते हैं।

है

अगर हम सिर्फ यह जानना चाहते हैं कि हमारी वस्तु में कोई संपत्ति है, तो उसके मूल्य को पढ़े बिना, हम उसके गुणों की जांच करने के लिए फ़ंक्शन का उपयोग कर सकते हैं, साथ ही प्रोटोटाइप श्रृंखला की जाँच करने के लिए hasIn : has('name', person) ।

पथ

जहाँ prop एक ऑब्जेक्ट प्रॉपर्टी को prop , रास्ता नेस्टेड ऑब्जेक्ट्स में गहराई से जाता है। उदाहरण के लिए, हम ज़िप कोड को एक गहरी संरचना से खींचना चाहते हैं: path(['address','zipCode'], person) ।

ध्यान दें कि path prop से अधिक क्षमाशील है। यदि पथ में कुछ भी undefined हो (मूल तर्क सहित) null या undefined , जबकि prop ऐसी स्थितियों में त्रुटि का कारण होगा।

propOr / pathOr

PropOr और pathOr, PropTo के साथ संयुक्त path और path के समान हैं। वे आपको एक संपत्ति या पथ के लिए एक डिफ़ॉल्ट मान निर्दिष्ट करने की क्षमता प्रदान करते हैं जो अध्ययन की जा रही वस्तु में नहीं मिल सकता है।

उदाहरण के लिए, हम एक प्लेसहोल्डर प्रदान कर सकते हैं जब हम उस व्यक्ति का नाम नहीं जानते हैं: propOr('<Unnamed>, 'name', person) । ध्यान दें कि prop विपरीत, propOr त्रुटि नहीं करेगा यदि person null या undefined ; इसके बजाय, यह डिफ़ॉल्ट मान लौटाएगा।

कुंजी / मान

कुंजियाँ ऑब्जेक्ट के सभी ज्ञात गुणों के सभी नामों से युक्त एक सरणी देता है। मान इन गुणों का मान लौटाएंगे। संग्रह के लिए पुनरावृत्ति कार्यों के साथ संयुक्त होने पर ये कार्य उपयोगी हो सकते हैं, जिनके बारे में हमने पहले भाग में सीखा।

गुण जोड़ें, अपडेट करें और हटाएं

अब हमारे पास एक घोषित शैली में वस्तुओं से पढ़ने के लिए कई उपकरण हैं, लेकिन परिवर्तन करने के बारे में क्या?

चूंकि अपरिवर्तनीयता हमारे लिए महत्वपूर्ण है, हम वस्तुओं को सीधे संशोधित नहीं करना चाहते हैं। इसके बजाय, हम नई वस्तुओं को वापस करना चाहते हैं जो हमारे इच्छित तरीके से बदल गए हैं।

एक बार फिर, रामदा हमें कई लाभ प्रदान करते हैं।

assoc / गधापठ

जब हम एक अनिवार्य शैली में कार्यक्रम करते हैं, तो हम असाइनमेंट ऑपरेटर के माध्यम से व्यक्ति का नाम सेट या बदल सकते हैं: person.name = 'New name' ।

हमारी कार्यात्मक, अपरिवर्तनीय दुनिया में, हम इसके बजाय const updatedPerson = assoc('name', 'newName', person) उपयोग कर सकते हैं: const updatedPerson = assoc('name', 'newName', person) ।

एक जोड़ा या अद्यतन संपत्ति के मूल्य के साथ एक नई वस्तु लौटाता है, मूल वस्तु को अपरिवर्तित छोड़ देता है।

संलग्न संपत्ति को अपडेट करने के लिए हमारे पास हमारे निपटान assocPath पर भी है: const updatedPerson = assocPath(['address', 'zipCode'], '97504', person) ।

dissoc / डिस्कोपथ / omit

गुणों को हटाने के बारे में क्या? मूल रूप से, हम व्यक्ति को delete person.age लिए कहना चाहते हैं। रामदा में, हम डिसोक का उपयोग करेंगे : `कास्ट अपडेटपर्सन = डिस्को (आयु), व्यक्ति)

dissocPath उसी के बारे में है, लेकिन गहरी वस्तु संरचनाओं पर काम करता है: dissocPath(['address', 'zipCode'], person) ।

और हमारे पास omit भी है, जो एक बार में कई गुण निकाल सकता है: const updatedPerson = omit(['age', 'birthCountry'], person) ।

कृपया ध्यान दें कि pick और omit समान हैं और एक दूसरे को बहुत अच्छी तरह से पूरक करते हैं। वे श्वेतवर्ण के लिए बहुत सुविधाजनक हैं (केवल pick का उपयोग करके गुणों का एक निश्चित सेट बचाएं) और ब्लैकलिस्ट ( omit के उपयोग के माध्यम से कुछ गुणों से छुटकारा)।

वस्तु परिवर्तन

अब हम एक घोषित और अपरिवर्तनीय शैली में वस्तुओं के साथ काम करने के लिए पर्याप्त जानते हैं। आइए एक celebrateBirthday डे फ़ंक्शन लिखें जो व्यक्ति के जन्मदिन पर उसकी आयु को अपडेट करता है।

 const nextAge = compose(inc, prop('age')) const celebrateBirthday = person => assoc('age', nextAge(person), person) 

यह एक बहुत ही सामान्य पैटर्न है। संपत्ति को नए मूल्य के साथ अपडेट करने के बजाय, हम वास्तव में फ़ंक्शन को पुराने मूल्य पर लागू करके बदलना चाहते हैं, जैसा कि हमने यहां किया था।

मुझे कम नक़ल और कम कठोर शैली के साथ इसे लिखने का एक अच्छा तरीका नहीं पता, उन उपकरणों के साथ जो हमने पहले के बारे में सीखा था।

रमदा एक बार फिर हमें विकसित कार्य के साथ बचाता है। evolve एक वस्तु को स्वीकार करता है और आपको उन गुणों के लिए परिवर्तन कार्यों को निर्दिष्ट करने की अनुमति देता है जिन्हें हम बदलना चाहते हैं। आइए celebrateBirthday । evolve के दिन जन्मदिन का celebrateBirthday :

 const celebrateBirthday = evolve({ age: inc }) 

यह कोड कहता है कि हम एक ही गुण और मूल्यों के साथ एक नई वस्तु बनाकर निर्दिष्ट वस्तु (जो कि क्रूर शैली के कारण प्रदर्शित नहीं होती है) को परिवर्तित कर देंगे, लेकिन age संपत्ति के मूल मूल्य को लागू करके age संपत्ति प्राप्त की जाएगी।

evolve कई गुणों को एक साथ बदल सकते हैं, और यहां तक ​​कि घोंसले के शिकार के कई स्तरों पर भी। ऑब्जेक्ट के परिवर्तन में एक ही छवि हो सकती है जैसा कि उत्परिवर्तित ऑब्जेक्ट में होगा, और evolve होगा संरचनाओं के बीच पुन: उत्तीर्ण होगा, निर्दिष्ट रूप में परिवर्तन कार्यों का उपयोग करके।

ध्यान दें कि evolve नए गुण नहीं evolve हैं; यदि आप किसी ऐसी संपत्ति के लिए एक परिवर्तन निर्दिष्ट करते हैं जो संसाधित होने वाली वस्तु में नहीं होती है, तो evolve इसे अनदेखा कर दिया जाएगा।

मैंने पाया कि मेरे अनुप्रयोगों में तेजी से वर्कहॉर्स बन रहा है।

वस्तुओं को मिलाएं

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

 function f(a, b, options = {}) { const defaultOptions = { value: 42, local: true } const finalOptions = merge(defaultOptions, options) } 

merge एक नई वस्तु देता है जिसमें सभी वस्तुओं से सभी गुण और मूल्य होते हैं। यदि दोनों वस्तुओं में समान संपत्ति है, तो दूसरे तर्क का मूल्य प्राप्त किया जाएगा।

एक विजेता दूसरे तर्क के साथ इस नियम की उपस्थिति एक आत्म-निहित उपकरण के रूप में merge का उपयोग करने के लिए सार्थक बनाती है, लेकिन संप्रेषित स्थितियों में कम सार्थक है। इस मामले में, आपको अक्सर किसी वस्तु के लिए परिवर्तनों की एक श्रृंखला तैयार करने की आवश्यकता होती है, और ऐसे परिवर्तनों में से एक कुछ नए संपत्ति मूल्यों का संघ है। इस मामले में, आप चाहते हैं कि पहला तर्क दूसरे के बजाय जीतने के लिए होगा।

पाइपलाइन में केवल merge(newValues) उपयोग करने की कोशिश करने से वह नहीं मिलेगा जो हम प्राप्त करना चाहते हैं।

इस स्थिति के लिए, मैं आमतौर पर अपनी उपयोगिता बनाता हूं जिसे reverseMerge कहा जाता है। इसे const reverseMerge = flip(merge) रूप में लिखा जा सकता है। flip कॉल उस पर लागू होने वाले फ़ंक्शन के पहले दो तर्कों को स्वैप करता है।

merge एक सतह merge करता है। यदि वस्तुओं, जब संयुक्त होते हैं, तो एक संपत्ति होती है जिसका मूल्य एक उप-विषय है, तो ये उप-विषय विलय नहीं करते हैं। रामदा में वर्तमान में गहरी मर्ज क्षमता नहीं है ( मूल लेख जिसका मैं अनुवाद कर रहा हूं, पहले से ही इस विषय पर पुरानी जानकारी है। आज रमाडा के पास मर्जडिप्प्लिफ्ट , मर्जडिपेयर राइट्स के लिए पुनरावर्ती गहरी मर्जिंग ऑब्जेक्ट्स और मर्जिंग के लिए अन्य तरीके हैं ।

ध्यान दें कि merge केवल दो तर्कों को स्वीकार करता है। यदि आप कई वस्तुओं को एक में जोड़ना चाहते हैं, तो आप मर्ज ऑल का उपयोग कर सकते हैं, जो गठबंधन करने के लिए वस्तुओं की एक सरणी लेता है।

निष्कर्ष

आज हमें एक घोषित और अपरिवर्तनीय शैली में वस्तुओं के साथ काम करने के लिए उपकरणों का एक अद्भुत सेट मिला है। अब हम मूल वस्तुओं को बदले बिना वस्तुओं में गुणों को पढ़ सकते हैं, जोड़ सकते हैं, अपडेट कर सकते हैं, हटा सकते हैं और बदल सकते हैं। और हम इन सभी चीजों को एक शैली में कर सकते हैं जो एक दूसरे के साथ कार्यों को संयोजित करना आसान बनाता है।

आगे

अब हम एक अपरिवर्तनीय शैली में वस्तुओं के साथ काम कर सकते हैं, लेकिन सरणियों के बारे में क्या? "प्रतिरक्षा और सरणियाँ" हमें बताएंगे कि उनके साथ क्या करना है।