रूबी एन्यूमेरेबल्स को टुकड़ा करना और काटना

आज हम बात करने जा रहे हैं 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 . के लिए रूबी डॉक्स देखें . उनके पास कई बेहतरीन कोड उदाहरण हैं।

Arrays vs Enumerables

मैंने ऊपर के अधिकांश उदाहरणों में सरणियों का उपयोग किया है क्योंकि सरणियों को समझना आसान है। हालांकि आपको यह ध्यान रखना चाहिए कि आप 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 और आपके अन्य सभी पसंदीदा गणनीय तरीके। बिल्ली, आप एक और विभाजन भी कर सकते हैं। :)