ruby - रुबी में स्विच स्टेटमेंट कैसे लिखें?




switch-statement conditional (14)

मैं रुबी में एक स्विच स्टेटमेंट कैसे लिखूं?


मामले ... जब

चक के जवाब में और उदाहरण जोड़ने के लिए:

पैरामीटर के साथ:

case a
when 1
  puts "Single value"
when 2, 3
  puts "One of comma-separated values"
when 4..6
  puts "One of 4, 5, 6"
when 7...9
  puts "One of 7, 8, but not 9"
else
  puts "Any other thing"
end

पैरामीटर के बिना:

case
when b < 3
  puts "Little than 3"
when b == 3
  puts "Equal to 3"
when (1..10) === b
  puts "Something in closed range of [1..10]"
end

कृपया, उस मुद्दे से अवगत रहें जो किकिटो चेतावनी देता है।


आप इसे अधिक प्राकृतिक तरीके से कर सकते हैं,

case expression
when condtion1
   function
when condition2
   function
else
   function
end

आप रूबी में दो अलग-अलग तरीकों से केस एक्सप्रेशन लिख सकते हैं।

  1. "If" कथन की एक श्रृंखला के समान
  2. मामले के बगल में एक लक्ष्य निर्दिष्ट करें और प्रत्येक "कब" खंड की तुलना लक्ष्य से की जाती है।

पहला रास्ता

age = 20
case 
when age >= 21
puts "display something"
when 1 == 0
puts "omg"
else
puts "default condition"
end

दूसरा रास्ता

 case params[:unknown]
 when /Something/ then 'Nothing'
 when /Something else/ then 'I dont know'
 end

आपके पर्यावरण में नियमित अभिव्यक्तियों के लिए कोई समर्थन नहीं है? जैसे Shopify स्क्रिप्ट संपादक (अप्रैल, 2018):

[त्रुटि]: अनियमित स्थिर RegExp

here पहले और here पहले से कवर किए गए तरीकों के संयोजन के बाद एक कार्यवाही:

code = '!ADD-SUPER-BONUS!'

class StrContains
  def self.===(item)
    item.include? 'SUPER' or item.include? 'MEGA' or\
    item.include? 'MINI' or item.include? 'UBER'
  end
end

case code.upcase
when '12345PROMO', 'CODE-007', StrContains
  puts "Code #{code} is a discount code!"
when '!ADD-BONUS!'
  puts 'This is a bonus code!'
else
  puts 'Sorry, we can\'t do anything with the code you added...'
end

मैंने क्लास विधि कथन में इस्तेमाल किया है or || की तुलना में अधिक प्राथमिकता है .include? । यदि आप ruby-nazi , तो कृपया कल्पना करें कि मैंने इसका इस्तेमाल किया है (item.include? 'A') || ... (item.include? 'A') || ... इसके बजाए। repl.it परीक्षण।


इसे case कहा जाता case और यह काम करता है जैसे आप उम्मीद करेंगे, प्लस बहुत अधिक मजेदार सामान === सौजन्य जो परीक्षण लागू करता है।

case 5
  when 5
    puts 'yes'
  else
    puts 'else'
end

अब कुछ मज़ा के लिए:

case 5 # every selector below would fire (if first)
  when 3..7    # OK, this is nice
  when 3,4,5,6 # also nice
  when Fixnum  # or
  when Integer # or
  when Numeric # or
  when Comparable # (?!) or
  when Object  # (duhh) or
  when Kernel  # (?!) or
  when BasicObject # (enough already)
    ...
end

और यह पता चला है कि अगर आप प्रारंभिक case पैरामीटर को छोड़कर और केवल अभिव्यक्ति लिखते हैं, तो पहला मिलान वह है जो आप / और चेन (यानी, यदि परीक्षण में एक सामान्य चर शामिल नहीं है) भी मनमाने ढंग से प्रतिस्थापित कर सकते हैं। चाहते हैं।

case
  when x.nil?
    ...
  when (x.match /'^fn'/)
    ...
  when (x.include? 'substring')
    ...
  when x.gsub('o', 'z') == 'fnzrq'
    ...
  when Time.now.tuesday?
    ...
end

कई प्रोग्रामिंग भाषाएं, विशेष रूप से सी से व्युत्पन्न, तथाकथित स्विच Fallthrough के लिए समर्थन है। मैं रूबी में ऐसा करने का सबसे अच्छा तरीका खोज रहा था और सोचा कि यह दूसरों के लिए उपयोगी हो सकता है:

सी-जैसी भाषाओं में गिरावट आमतौर पर इस तरह दिखती है:

switch (expression) {
    case 'a':
    case 'b':
    case 'c':
        // Do something for a, b or c
        break;
    case 'd':
    case 'e':
        // Do something else for d or e
        break;
}

रूबी में, इसे निम्न तरीके से हासिल किया जा सकता है:

case expression
when 'a', 'b', 'c'
  # Do something for a, b or c
when 'd', 'e'
  # Do something else for d or e
end

यह सख्ती से समकक्ष नहीं है, क्योंकि 'b' या 'c' से गिरने से पहले 'b' को कोड के ब्लॉक को निष्पादित करना संभव नहीं है, लेकिन अधिकांश भाग के लिए मुझे इसे समान तरीके से उपयोगी होने के लिए पर्याप्त लगता है।


जैसा कि उपर्युक्त उत्तरों में से कई में बताया गया है, === ऑपरेटर का उपयोग केस / जब वक्तव्य पर हुड के तहत किया जाता है।

उस ऑपरेटर के बारे में कुछ अतिरिक्त जानकारी यहां दी गई है।

केस समानता ऑपरेटर: ===

रूबी के निर्मित कक्षाओं में से कई, जैसे स्ट्रिंग, रेंज, और रेगेक्सपी, === ऑपरेटर के अपने कार्यान्वयन प्रदान करते हैं, जिन्हें केस-समानता, ट्रिपल बराबर या तीन खंड भी कहा जाता है। क्योंकि यह प्रत्येक वर्ग में अलग-अलग लागू होता है, यह उस वस्तु के प्रकार के आधार पर अलग-अलग व्यवहार करेगा जिस पर इसे बुलाया गया था। आम तौर पर, यह सही हो जाता है अगर दाईं ओर ऑब्जेक्ट बाईं ओर ऑब्जेक्ट "से संबंधित" या "सदस्य" है। उदाहरण के लिए, इसका उपयोग यह जांचने के लिए किया जा सकता है कि कोई ऑब्जेक्ट किसी वर्ग (या उसके उप-वर्गों में से एक) का उदाहरण है या नहीं।

String === "zen"  # Output: => true
Range === (1..2)   # Output: => true
Array === [1,2,3]   # Output: => true
Integer === 2   # Output: => true

वही परिणाम अन्य विधियों के साथ हासिल किया जा सकता है जो शायद नौकरी के लिए सबसे उपयुक्त हैं, जैसे is_a? और example_of ?.

=== की रेंज कार्यान्वयन

जब === ऑपरेटर को किसी रेंज ऑब्जेक्ट पर कॉल किया जाता है, तो दाएं तरफ दायीं तरफ दायीं तरफ के दाम के भीतर यह सही होता है।

(1..4) === 3  # Output: => true
(1..4) === 2.345 # Output: => true
(1..4) === 6  # Output: => false

("a".."d") === "c" # Output: => true
("a".."d") === "e" # Output: => false

याद रखें कि === ऑपरेटर बाईं ओर ऑब्जेक्ट की === विधि को आमंत्रित करता है। तो (1..4) === 3 बराबर है (1..4)। === 3. दूसरे शब्दों में, बाएं हाथ के ऑपरेंड की कक्षा परिभाषित करेगी कि === विधि का कौन सा कार्यान्वयन होगा कहा जाता है, तो ऑपरेंड पदों को बदलने योग्य नहीं हैं।

Regexp कार्यान्वयन ===

सही पर वापस आता है यदि दाईं ओर की स्ट्रिंग बाईं ओर नियमित अभिव्यक्ति से मेल खाती है। / जेन / === "आज ज़ज़ेन का अभ्यास करें" # आउटपुट: => सच्चा # "अभ्यास ज़ज़ेन आज" = ~ / जेन /

ऊपर दिए गए दो उदाहरणों के बीच एकमात्र प्रासंगिक अंतर यह है कि, जब कोई मिलान होता है, === सत्य लौटाता है और = ~ एक पूर्णांक देता है, जो रूबी में एक वास्तविक मूल्य है। हम जल्द ही इस पर वापस आ जाएंगे।


बहुत सारे महान उत्तर लेकिन मैंने सोचा कि मैं एक फैक्टोइड जोड़ूंगा .. यदि आप ऑब्जेक्ट्स (क्लासेस) की तुलना करने का प्रयास कर रहे हैं तो सुनिश्चित करें कि आपके पास स्पेस शिप विधि है (मजाक नहीं) या समझें कि उनकी तुलना कैसे की जा रही है

यहां विषय पर एक अच्छी चर्चा है http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/


मैंने उपयोग करना शुरू कर दिया है:

a = "secondcase"

var_name = case a
  when "firstcase" then "foo"
  when "secondcase" then "bar"
end

puts var_name
>> "bar"

यह कुछ मामलों में कॉम्पैक्ट कोड में मदद करता है।



रुबी 2.0 में, आप कथन के case में लैम्बडा का भी उपयोग कर सकते हैं, जैसा कि निम्नानुसार है:

is_even = ->(x) { x % 2 == 0 }

case number
when 0 then puts 'zero'
when is_even then puts 'even'
else puts 'odd'
end

आप एक कस्टम === साथ एक स्ट्रक्चर का उपयोग करके आसानी से अपने स्वयं के तुलनित्र भी बना सकते हैं

Moddable = Struct.new(:n) do
  def ===(numeric)
    numeric % n == 0
  end
end

mod4 = Moddable.new(4)
mod3 = Moddable.new(3)

case number
when mod4 then puts 'multiple of 4'
when mod3 then puts 'multiple of 3'
end

(उदाहरण से लिया गया है " क्या रूबी 2.0 में केस कथन के साथ प्रसंस्करण किया जा सकता है? "।)

या, एक पूर्ण वर्ग के साथ:

class Vehicle
  def ===(another_vehicle)
    self.number_of_wheels == another_vehicle.number_of_wheels
  end
end

four_wheeler = Vehicle.new 4
two_wheeler = Vehicle.new 2

case vehicle
when two_wheeler
  puts 'two wheeler'
when four_wheeler
  puts 'four wheeler'
end

(उदाहरण " कैसे एक रूबी केस स्टेटमेंट वर्क्स और आप इसके साथ क्या कर सकते हैं " से लिया गया उदाहरण।)


रूबी स्विच स्टेटमेंट लिखने के case का उपयोग करता है।

रूबी डॉक्स के अनुसार:

केस स्टेटमेंट में एक वैकल्पिक स्थिति होती है, जो case लिए तर्क की case , और क्लोज़ के दौरान शून्य या अधिक when । पहली बार when स्थिति से मेल खाने के लिए क्लॉज (या बूलियन सच्चाई का मूल्यांकन करने के लिए, यदि स्थिति शून्य है) "जीत जाती है", और इसका कोड स्टांजा निष्पादित किया जाता है। केस स्टेटमेंट का मूल्य सफल when का मूल्य है, या अगर ऐसा कोई खंड नहीं है तो nil

एक केस स्टेटमेंट किसी else खंड के साथ समाप्त हो सकता है। प्रत्येक when एक कथन में एकाधिक उम्मीदवार मान हो सकते हैं, अल्पविराम से अलग हो जाते हैं।

उदाहरण:

case x
when 1,2,3
  puts "1, 2, or 3"
when 10
  puts "10"
else
  puts "Some other number"
end

छोटा संस्करण:

case x
when 1,2,3 then puts "1, 2, or 3"
when 10 then puts "10"
else puts "Some other number"
end

और चूंकि Honeybadger द्वारा इस ब्लॉग ने रूबी केस का वर्णन किया है;

Ranges साथ इस्तेमाल किया जा सकता Ranges :

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

## => "case statements match inclusion in a range"

Regex साथ इस्तेमाल किया जा सकता है:

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

## => "they can match regular expressions!"

प्रो और लैम्बडास के साथ इस्तेमाल किया जा सकता है:

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

## => "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

रूबी इसके बजाय case अभिव्यक्ति का उपयोग करता है।

case x
when 1..5
  "It's between 1 and 5"
when 6
  "It's 6"
when "foo", "bar"
  "It's either foo or bar"
when String
  "You passed a string"
else
  "You gave me #{x} -- I have no idea what to do with that."
end

रुबी ऑब्जेक्ट की तुलना करता है when ऑब्जेक्ट के साथ क्लॉज === ऑपरेटर का उपयोग करते हुए case क्लॉज में होता है। उदाहरण के लिए, 1..5 === x , और x === 1..5

यह उपरोक्त के रूप में क्लॉज के रूप में परिष्कृत के लिए अनुमति देता है। रेंज, कक्षाएं और सभी प्रकार की चीजों का परीक्षण समानता के बजाय किया जा सकता है।

कई अन्य भाषाओं में switch स्टेटमेंट के विपरीत, रूबी के case में fall-through नहीं होती है, इसलिए break साथ प्रत्येक को समाप्त करने की आवश्यकता नहीं होती है। when "foo", "bar" तरह क्लॉज करते हैं when "foo", "bar" एकल में एकाधिक मिलान भी निर्दिष्ट कर सकते हैं।






conditional