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

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

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

छठे भाग में, हमने कार्यात्मक और अपरिवर्तनीय शैली में जावास्क्रिप्ट वस्तुओं के साथ काम करने के बारे में बात की।

इस पोस्ट में हम सरणियों के साथ इसी तरह के काम के बारे में बात करेंगे।

सरणी तत्वों को पढ़ना

छठे भाग में, हमने वस्तुओं के गुणों को पढ़ने के लिए विभिन्न रामदा कार्यों के बारे में सीखा, जैसे कि prop , pick और has । रामदा में सरणी तत्वों को पढ़ने के लिए और भी अधिक तरीके हैं।

किसी सरणी के लिए prop बराबर nth है ; pick लिए बराबर स्लाइस है , और इसके लिए बराबर समाहित है । आइए उन पर एक नज़र डालें।

 const numbers = [10, 20, 30, 40, 50, 60] nth(3, numbers) // => 40 (  ) nth(-2, numbers) // => 50 (     ) slice(2, 5, numbers) // => [30, 40, 50] (. ) contains(20, numbers) // => true 

स्लाइस दो इंडेक्स लेता है और एक सबर्रे देता है जो पहले इंडेक्स पर शुरू होता है (शून्य से शुरू होता है) और दूसरे इंडेक्स तक सभी तत्वों को शामिल करता है, लेकिन इस इंडेक्स के तत्व को शामिल नहीं करता है।

किसी सरणी के पहले और अंतिम तत्वों तक पहुँच प्राप्त करना बहुत आम है, इसलिए रामदा इन मामलों, सिर और आखिरी के लिए छोटे कार्य प्रदान करता है। यह पहले ( पूंछ ), सभी लेकिन अंतिम ( init ), पहले N तत्वों ( ले (N) ), और अंतिम N तत्वों ( takeLast (N) ) को छोड़कर सभी तत्वों को प्राप्त करने के लिए कार्य प्रदान करता है। आइए उन पर कार्रवाई करते हैं।

 const numbers = [10, 20, 30, 40, 50, 60] head(numbers) // => 10 tail(numbers) // => [20, 30, 40, 50, 60] last(numbers) // => 60 init(numbers) // => [10, 20, 30, 40, 50] take(3, numbers) // => [10, 20, 30] takeLast(3, numbers) // => [40, 50, 60] 

सरणी तत्वों को जोड़ें, अपडेट करें और हटाएं

वस्तुओं के साथ काम करने के तरीके का अध्ययन करते हुए, हमने गुणों को जोड़ने, अद्यतन करने, और गुणों को हटाने के लिए कार्य करना, dissoc और omit सीखा।

चूंकि सरणियों में एक ऑर्डर की गई डेटा संरचना होती है, इसलिए हमारे पास कई विधियां हैं जो ऑब्जेक्ट्स के लिए समान कार्य करती हैं। सबसे आम सम्मिलित हैं और अद्यतन करते हैं , लेकिन रामदा एक सरणी की शुरुआत और अंत में तत्वों को जोड़ने के विशिष्ट मामलों के लिए एपेंड और प्रीपेंड तरीके भी प्रदान करता है। insert , append , और prepend सरणी में नए तत्व जोड़ें; update "प्रतिस्थापित करता है" एक नए मान के साथ सरणी में एक विशिष्ट तत्व।

जैसा कि आप एक कार्यात्मक पुस्तकालय से उम्मीद कर सकते हैं, ये सभी फ़ंक्शन अपेक्षित परिवर्तनों के साथ एक नया सरणी लौटाते हैं; मूल सरणी कभी नहीं बदलता है।

 const numbers = [10, 20, 30, 40, 50, 60] insert(3, 35, numbers) // => [10, 20, 30, 35, 40, 50, 60] append(70, numbers) // => [10, 20, 30, 40, 50, 60, 70] prepend(0, numbers) // => [0, 10, 20, 30, 40, 50, 60] update(1, 15, numbers) // => [10, 15, 30, 40, 50, 60] 

दो वस्तुओं को एक में मिलाने के लिए, हमने पहले merge विधि के बारे में सीखा। Ramda सरणियों के साथ एक ही ऑपरेशन करने के लिए एक कॉनैट विधि भी प्रदान करता है।

 const numbers = [10, 20, 30, 40, 50, 60] concat(numbers, [70, 80, 90]) // => [10, 20, 30, 40, 50, 60, 70, 80, 90] 

ध्यान दें कि दूसरा सरणी पहले में शामिल हो गया है। इस पद्धति का उपयोग अन्य कोड से अलग करने पर यह तर्कसंगत लगता है, लेकिन merge तरह, यह तर्क बिल्कुल वैसा नहीं हो सकता जैसा हम अपनी पाइपलाइन में इस पद्धति का उपयोग करने पर उम्मीद करेंगे। मुझे एक सहायक समारोह लिखने के लिए उपयोगी पाया गया, concatAfter : const concatAfter = flip(concat) , इसे मेरी पाइपलाइनों में उपयोग करने के लिए।

रामदा आइटम हटाने के लिए कई विकल्प भी प्रदान करता है। हटाने उनके सूचकांक द्वारा आइटम निकालता है, जबकि उनके मूल्य द्वारा उन्हें हटाए बिना । जब हम किसी सरणी के आरंभ या अंत से तत्वों को निकालते हैं, तो विशिष्ट मामलों के लिए ड्रॉप और ड्रॉपलैस्ट जैसी विधियाँ भी होती हैं।

 const numbers = [10, 20, 30, 40, 50, 60] remove(2, 3, numbers) // => [10, 20, 60] without([30, 40, 50], numbers) // => [10, 20, 60] drop(3, numbers) // => [40, 50, 60] dropLast(3, numbers) // => [10, 20, 30] 

ध्यान दें कि एक इंडेक्स और एक राशि को remove , जबकि slice दो इंडेक्स को स्वीकार करता है। यदि आप इसके बारे में नहीं जानते हैं तो यह असंगतता भ्रामक हो सकती है।

तत्व रूपांतरण

वस्तुओं के साथ, हम फ़ंक्शन को मूल मान पर लागू करके सरणी तत्व को अपडेट करना चाह सकते हैं।

 const numbers = [10, 20, 30, 40, 50, 60] //      10 update(2, multiply(10, nth(2, numbers)), numbers) // => [10, 20, 300, 40, 50, 60] 

इस विशिष्ट मामले को सरल बनाने के लिए, रामदा एक समायोजन विधि प्रदान करता है जो वस्तुओं के लिए evolve होने जैसा काम करता है। लेकिन evolve विपरीत, सरणी के केवल एक तत्व के साथ काम adjust ।

 const numbers = [10, 20, 30, 40, 50, 60] //      10 adjust(multiply(10), 2, numbers) 

ध्यान दें कि adjust करने के लिए पहले दो तर्क update साथ तुलना करते समय दूसरे रास्ते पर जाते हैं। यह त्रुटियों का एक स्रोत हो सकता है, लेकिन यह समझ में आता है जब आप एक आंशिक आवेदन पर विचार करते हैं। आप अपने लिए adjust(multiply(10)) करना चाहते हैं और बाद में यह तय कर सकते हैं कि इसका उपयोग करने के लिए सरणी के किस सूचकांक को बदलना है।

निष्कर्ष

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

आगे

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