आज हम slice_before, slice_when और slice_after के बारे में बात करने जा रहे हैं। ये सुपर-उपयोगी मेथड हैं जब आपको किसी सरणी या अन्य एन्यूमरेबल में आइटम को मनमाने मानदंडों के आधार पर समूहित करने की आवश्यकता होती है।
आप शायद Array#slice से परिचित हैं। यह आपको इंडेक्स की एक श्रृंखला के आधार पर एक सरणी का सबसेट निकालने देता है:
a = ["a", "b", "c"] a.slice(1, 2) # => ["b", "c"] यह उपयोगी है, लेकिन इसका उपयोग एन्यूमरेबल के साथ नहीं किया जा सकता, क्योंकि एन्यूमरेबल के इंडेक्स नहीं होते।
slice_before, slice_when और slice_after मेथड इंडेक्स पर भरोसा नहीं करते - इसलिए आप इन्हें किसी भी एन्यूमरेबल के साथ उपयोग कर सकते हैं। आइए एक नज़र डालें!
Enumerable#slice_before का उपयोग
Enumerable#slice_before एक एन्यूमरेबल को उस बिंदु से पहले समूहों में विभाजित करता है जहां एक मैच बनाया जाता है।
मैच === ऑपरेटर के माध्यम से किया जाता है, जिसका अर्थ है कि आप सभी प्रकार की चीजों से मेल खा सकते हैं।
मान मिलान
आप एकल मान से मिलान कर सकते हैं। यह स्पष्ट होना चाहिए। :)
a = ["a", "b", "c"] a.slice_before("b").to_a # => [["a"], ["b", "c"]] रेगुलर एक्सप्रेशन मिलान
आप अधिक जटिल टेक्स्ट मिलान के लिए रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं।
a = ["000", "b", "999"] a.slice_before(/[a-z]/).to_a # => [["000"], ["b", "999"]] रेंज मिलान
यदि आप नंबर के साथ काम कर रहे हैं, तो आप सरणी को रेंज के आधार पर स्लाइस कर सकते हैं।
a = [100, 200, 300] a.slice_before(150..250).to_a # => [[100], [200, 300]] क्लास मिलान
यह आपको थोड़ा अजीब लग सकता है, लेकिन यह === ऑपरेटर के व्यवहार के पूरी तरह अनुरूप है।
a = [1, "200", 1.3] a.slice_before(String).to_a # => [[1], ["200", 1.3]] ब्लॉक का उपयोग
यदि अन्य विकल्पों में से कोई भी आपके लिए पर्याप्त लचीला नहीं है तो आप हमेशा ब्लॉक के साथ प्रोग्रामेटिक रूप से एक मैच ढूंढ सकते हैं।
a = [1, 2, 3, 4, 5] a.slice_before do |item| item % 2 == 0 end # => [[1], [2, 3], [4, 5]] Enumerable#slice_after का उपयोग
Enumerable#slice_after Enumerable#slice_before की तरह ही काम करता है सिवाय इसके कि स्लाइस मैच के बाद होता है। जाहिर है। :-)
a = ["a", "b", "c"] a.slice_after("b").to_a # => [["a", "b"], ["c"]] बेशक, आप रेगुलर एक्सप्रेशन, रेंज, और ब्लॉक का उपयोग करके मिलान कर सकते हैं। मैं यहां उन उदाहरणों को नहीं दिखाने जा रहा हूँ क्योंकि यह थकाऊ होगा।
Enumerable#slice_when का उपयोग
Enumerable#slice_when slice_before और slice_after से एक अलग जानवर है। सरणी में एकल आइटम से मिलान करने के बजाय, आप आसन्न आइटम की एक जोड़ी से मिलान करते हैं।
इसका मतलब है कि आप उनके बीच के "किनारों" के आधार पर आइटम को समूहित कर सकते हैं।
उदाहरण के लिए, यहां हम आइटम को उनके आसन्न आइटम के "पास" होने के आधार पर समूहित करते हैं।
a = [1, 2, 3, 100, 101, 102] # Create a new group when the difference # between two adjacent items is > 10. a.slice_when do |x, y| (y - x) > 10 end # => [[1, 2, 3], [100, 101, 102]] यदि आप अधिक सीखने में रुचि रखते हैं, तो slice_when के लिए रूबी डॉक्स देखें। उनके पास कई बेहतरीन कोड उदाहरण हैं।
सरणी बनाम एन्यूमरेबल
मैंने ऊपर अधिकांश उदाहरणों में सरणी का उपयोग किया है क्योंकि सरणी समझने में आसान हैं। आपको ध्यान रखना चाहिए कि आप slice_before, slice_when और slice_after का उपयोग किसी भी एन्यूमरेबल के साथ कर सकते हैं।
उदाहरण के लिए, यदि आपके पास ईमेल का एक गुच्छा वाली फाइल है, तो आप slice_before का उपयोग करके व्यक्तिगत ईमेल को विभाजित कर सकते हैं। नीचे दिया गया कोड डॉक्स से लिया गया है।
open("mbox") { |f| f.slice_before { |line| line.start_with? "From " }.each { |mail| puts mail } और यह नोटिस करना सुनिश्चित करें कि स्लाइस मेथड सरणी नहीं लौटाते। वे एन्यूमरेबल लौटाते हैं। इसका मतलब है कि आप उन पर map, each और अपने अन्य सभी पसंदीदा एन्यूमरेबल मेथड का उपयोग कर सकते हैं। बिल्कुल, आप एक और विभाजन भी कर सकते हैं। :)
