रूबी केस स्टेटमेंट - उन्नत तकनीकें

केस स्टेटमेंट से ज्यादा सरल और उबाऊ कुछ नहीं हो सकता। यह C से होल्डओवर है। आप इसका उपयोग ifs के एक समूह को बदलने के लिए करते हैं। मामला बंद। या है?

दरअसल, रूबी में केस स्टेटमेंट आपकी कल्पना से कहीं अधिक समृद्ध और अधिक जटिल हैं। आइए केवल एक उदाहरण पर एक नज़र डालें:

case "Hi there"
when String
  puts "case statements match class"
end

# outputs: "case statements match class"

यह उदाहरण दिखाता है कि केस स्टेटमेंट न केवल किसी आइटम के मान . से मेल खाते हैं लेकिन इसकी वर्ग . भी . यह संभव है क्योंकि हुड के तहत, रूबी === . का उपयोग करती है ऑपरेटर, उर्फ। तीन बराबर ऑपरेटर।

=== का एक त्वरित दौरा ऑपरेटर

जब आप x === y write लिखते हैं y रूबी में, आप पूछ रहे हैं "क्या y x द्वारा दर्शाए गए समूह में है?" यह एक बहुत ही सामान्य कथन है। आप जिस प्रकार के समूह के साथ काम कर रहे हैं, उसके आधार पर विवरण अलग-अलग होते हैं।

# Here, the Class.===(item) method is called, which returns true if item is an instance of the class 

String === "hello" # true
String === 1 # false

स्ट्रिंग्स, रेगुलर एक्सप्रेशन और रेंज सभी अपने-अपने ===(item) . को परिभाषित करते हैं तरीके, जो आपकी अपेक्षा के अनुरूप कमोबेश व्यवहार करते हैं। आप अपनी कक्षाओं में एक तिहाई बराबर विधि भी जोड़ सकते हैं।

अब जब हम यह जान गए हैं, तो हम केस के साथ हर तरह की चालें कर सकते हैं।

केस स्टेटमेंट में मैचिंग रेंज

आप केस स्टेटमेंट में रेंज का उपयोग कर सकते हैं, इस तथ्य के लिए धन्यवाद कि range === n बस range.include?(n) . का मान लौटाता है . मुझे इतना यकीन कैसे हो सकता है? यह डॉक्स में है।

case 5
when (1..10)
  puts "case statements match inclusion in a range"
end

# outputs "case statements match inclusion in a range"

केस स्टेटमेंट के साथ रेगुलर एक्सप्रेशन का मिलान

केस स्टेटमेंट में रेगेक्स का इस्तेमाल करना भी संभव है, क्योंकि /regexp/ === "string" केवल तभी सत्य लौटाता है जब स्ट्रिंग नियमित अभिव्यक्ति से मेल खाती है। Regexp . के लिए दस्तावेज़ इसे समझाएं।

case "FOOBAR"
when /BAR$/
  puts "they can match regular expressions!"
end

# outputs "they can match regular expressions!"

मैचिंग प्रोसेस और लैम्बडास

यह एक अजीब तरह का है। जब आप उपयोग करते हैं   Proc#===(item) , यह Proc#call(item) . करने जैसा ही है . इसके लिए यहां दस्तावेज़ हैं। इसका मतलब यह है कि आप अपने केस स्टेटमेंट में डायनामिक मैचर्स के रूप में लैम्ब्डा और प्रोसेस का उपयोग कर सकते हैं।

case 40
when -> (n) { n.to_s == "40" }
  puts "lambdas!"
end

# outputs "lambdas"

अपनी खुद की मैचर क्लासेस लिखना

जैसा कि मैंने ऊपर उल्लेख किया है, अपनी कक्षाओं में कस्टम केस व्यवहार जोड़ना उतना ही सरल है जितना कि अपने स्वयं के === को परिभाषित करना तरीका। इसके लिए एक उपयोग जटिल सशर्त तर्क को कई छोटे वर्गों में खींचना हो सकता है। मैंने नीचे दिए गए उदाहरण में यह बताया है कि यह कैसे काम कर सकता है:

class Success
  def self.===(item)
    item.status >= 200 && item.status < 300
  end
end

class Empty
  def self.===(item)
    item.response_size == 0
  end
end

case http_response
when Empty
  puts "response was empty"
when Success
  puts "response was a success"
end