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

Question

मैं switchरूबी में एक बयान कैसे लिखूं ?

Answer 1

रूबी इसके बजाय 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 === xx === 1..5

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

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

Comments

जब / thisisregex /: तुम भी पारित कर दिया तर्क पर regex कर सकते हैं अगली पंक्ति अंत डालता है "यह मिली मैच एन.आर. है 1 # {$ 1}।"

— Automatico

यह भी ध्यान देने योग्य है, आप एक ही लाइन पर whenऔर returnस्टेटमेंट डालकर अपने कोड को छोटा कर सकते हैं :when "foo" then "bar"

— अलेक्जेंडर - मोनिका

महत्वपूर्ण:switch कई अन्य भाषाओं में बयानों के विपरीत , रूबी के caseपास गिरावट नहीं है , इसलिए प्रत्येक whenको एक के साथ समाप्त करने की आवश्यकता नहीं है break।

— जन्निक्स

इतने सारे वोट अभी भी कीवर्ड का उल्लेख नहीं है then। कृपया अन्य उत्तर भी देखें।

— क्लिंट पाचल

Answer 2

case...whenकक्षाओं को संभालने के दौरान अप्रत्याशित रूप से थोड़ा व्यवहार करता है। यह इस तथ्य के कारण है कि यह ===ऑपरेटर का उपयोग करता है ।

वह ऑपरेटर शाब्दिक के साथ अपेक्षा के अनुसार काम करता है, लेकिन वर्गों के साथ नहीं:

1 === 1           # => true
Fixnum === Fixnum # => false

इसका अर्थ है कि यदि आप case ... whenकिसी वस्तु के वर्ग को करना चाहते हैं , तो यह काम नहीं करेगा:

obj = 'hello'
case obj.class
when String
  print('It is a string')
when Fixnum
  print('It is a number')
else
  print('It is not a string or number')
end

"यह एक स्ट्रिंग या संख्या नहीं है" प्रिंट करेगा।

सौभाग्य से, यह आसानी से हल हो गया है। ===ऑपरेटर परिभाषित किया गया है इतना है कि यह देता है trueकि यदि आप एक वर्ग के साथ इसका इस्तेमाल और दूसरे संकार्य के रूप में उस वर्ग का एक उदाहरण की आपूर्ति:

Fixnum === 1 # => true

संक्षेप में, उपरोक्त कोड को हटाकर तय किया जा सकता है .class:

obj = 'hello'
case obj  # was case obj.class
when String
  print('It is a string')
when Fixnum
  print('It is a number')
else
  print('It is not a string or number')
end

मैंने उत्तर की तलाश करते हुए आज इस समस्या को मारा, और यह पहला दिखने वाला पृष्ठ था, इसलिए मुझे लगा कि यह मेरी उसी स्थिति में दूसरों के लिए उपयोगी होगा।

Comments

obj = 'हैलो'; केस obj; जब 'हैलो' तब "इट्स हेलो" अंत डालता है

— सुगुमार वेंकटेशन

होने .classमें भाग है, धन्यवाद टिप्पणी करने के लिए दिलचस्प है। बेशक, यह पूरी तरह से उचित व्यवहार है (हालांकि मैं देख सकता था कि यह सोचना एक सामान्य गलती कैसे हो सकती है कि यह प्रिंट होगा It is a string) ... आप कुछ मनमानी वस्तु के वर्ग का परीक्षण कर रहे हैं , न कि स्वयं वस्तु। तो, उदाहरण के लिए: case 'hello'.class when String then "String!" when Class then "Class!" else "Something else" endमें परिणाम: "Class!"इस के लिए एक ही काम करता है 1.class, {}.classआदि गिराने .classपर हम पाते हैं "String!"या "Something else"इन विभिन्न मूल्यों के लिए।

— lindes

Answer 3

यह caseरूबी में उपयोग किया जाता है । विकिपीडिया पर " स्विच स्टेटमेंट " भी देखें ।

उद्धरित:

case n
when 0
  puts 'You typed zero'
when 1, 9
  puts 'n is a perfect square'
when 2
  puts 'n is a prime number'
  puts 'n is an even number'
when 3, 5, 7
  puts 'n is a prime number'
when 4, 6, 8
  puts 'n is an even number'
else
  puts 'Only single-digit numbers are allowed'
end

एक और उदाहरण:

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

माई किंडल पर द रूबी प्रोग्रामिंग लैंग्वेज (प्रथम संस्करण, ओ'रिली) के पृष्ठ संख्या 123 के आसपास , यह कहता है कि thenक्लॉस के बाद वाले कीवर्ड whenको एक नई पंक्ति या अर्धविराम ( if then elseसिंटैक्स की तरह ) से बदला जा सकता है । (रूबी 1.8 के स्थान पर एक बृहदान्त्र की अनुमति देता है then, लेकिन रूबी 1.9 में इस वाक्यविन्यास की अब अनुमति नहीं है।)

Comments

when (-1.0/0.0)..-1 then "Epic fail"

— एंड्रयू ग्रिम

यह वह उत्तर है जिसका मैंने उपयोग किया था, क्योंकि मैं एक केस स्विच के परिणामों के आधार पर एक चर को परिभाषित कर रहा हूं। type = #{score}प्रत्येक पंक्ति कहने के बजाय , मैं बस वही कर सकता हूं जो आपने किया था। बहुत अधिक सुरुचिपूर्ण मुझे एक-लाइनर भी बहुत अच्छा लगता है (यदि संभव हो तो)

— वनब्री

मुझे पता है कि यह उत्तर के सार से संबंधित नहीं है, लेकिन 4 एक पूर्ण वर्ग भी है।

— निक मूर

Answer 4

मामले ... जब

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

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

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

कृपया, " रूबी में एक स्विच स्टेटमेंट कैसे लिखें " के बारे में जागरूक रहें जो किकिटो के बारे में चेतावनी देता है।

Comments

धन्यवाद, यह एक लाइन पर कई विकल्प रखने के लिए मददगार था। मैं का उपयोग करने की कोशिश कर रहा थाor

— साठ

Answer 5

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

सी-लाइक भाषाओं में आम तौर पर इस तरह दिखाई देती है:

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

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

Answer 6

रूबी 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

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

Answer 7

आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं, जैसे कि एक प्रकार की स्ट्रिंग खोजना:

case foo
when /^(true|false)$/
   puts "Given string is boolean"
when /^[0-9]+$/ 
   puts "Given string is integer"
when /^[0-9\.]+$/
   puts "Given string is float"
else
   puts "Given string is probably string"
end

रूबी की इस के लिए caseसमानता ऑपरेंड का उपयोग करेगी ===(धन्यवाद @JimDeville)। अतिरिक्त जानकारी " रूबी ऑपरेटरों " पर उपलब्ध है । यह @mmdemirbas उदाहरण (पैरामीटर के बिना) का उपयोग करके भी किया जा सकता है, केवल इस तरह के मामलों के लिए यह दृष्टिकोण क्लीनर है।

Answer 8

यदि आप यह जानने के लिए उत्सुक हैं कि रूबी स्विच मामले में OR शर्त का उपयोग कैसे करें:

तो, एक में caseबयान, एक ,के बराबर है ||एक में ifबयान।

case car
   when 'Maruti', 'Hyundai'
      # Code here
end

" कैसे एक रूबी केस स्टेटमेंट काम करता है और आप इसके साथ क्या कर सकते हैं " देखें।

Comments

कोड स्वरूपण लिंक किए गए लेख में काम नहीं कर रहा है :-)

— 23'18

Answer 9

यह कहा जाता है 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पैरामीटर और सिर्फ अभिव्यक्ति लिखने से जहां पहला मैच वह है जो आप चाहते हैं।

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

Answer 10

रूबी 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

---

और " रूबी के मामले के बयान - उन्नत तकनीकों " के रूप में रूबी का वर्णन है case;

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

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!"

Procs और Lambdas के साथ इस्तेमाल किया जा सकता है :

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

Answer 11

आपके मामले के आधार पर, आप तरीकों के हैश का उपयोग करना पसंद कर सकते हैं।

यदि whens की एक लंबी सूची है और उनमें से प्रत्येक के पास (अंतराल नहीं) के साथ तुलना करने के लिए एक ठोस मूल्य है, तो हैश के तरीकों की घोषणा करना और फिर उसी तरह हैश से संबंधित विधि को कॉल करना अधिक प्रभावी होगा।

# Define the hash
menu = {a: :menu1, b: :menu2, c: :menu2, d: :menu3}

# Define the methods
def menu1
  puts 'menu 1'
end

def menu2
  puts 'menu 2'
end

def menu3
  puts 'menu3'
end

# Let's say we case by selected_menu = :a
selected_menu = :a

# Then just call the relevant method from the hash
send(menu[selected_menu])

Answer 12

चूँकि switch caseहमेशा एक ही वस्तु वापस आती है, हम सीधे इसका परिणाम प्रिंट कर सकते हैं:

puts case a
     when 0
        "It's zero"
     when 1
        "It's one"
     end

Answer 13

बहु-मूल्य जब और नो-वैल्यू केस:

print "Enter your grade: "
grade = gets.chomp
case grade
when "A", "B"
  puts 'You pretty smart!'
when "C", "D"
  puts 'You pretty dumb!!'
else
  puts "You can't even use a computer!"
end

और यहाँ एक नियमित अभिव्यक्ति समाधान:

print "Enter a string: "
some_string = gets.chomp
case
when some_string.match(/\d/)
  puts 'String has numbers'
when some_string.match(/[a-zA-Z]/)
  puts 'String has letters'
else
  puts 'String has no numbers or letters'
end

Comments

क्यों नहीं case some_string, when /\d/, (stuff), when /[a-zA-Z]/, (stuff), end(जहां ,न्यूलाइन का मतलब है)

— दूरबीन

ओह, और पहला भाग पहले से ही इस उत्तर में शामिल है , और कई जवाब पहले से ही रेगेक्स का उल्लेख करते हैं। सच कहूँ तो, यह उत्तर कुछ नया नहीं जोड़ता है, और मैं इसे हटाने के लिए मतदान कर रहा हूँ और मतदान कर रहा हूँ।

— Doorknob

@DoorknobofSnow यह दिखाने के लिए है कि आप स्विच मामले में रेगेक्स समाधान और अल्पविराम से अलग मान का उपयोग कर सकते हैं। निश्चित नहीं है कि समाधान आपको इतना दर्द क्यों दे रहा है।

— 123

इसलिए यदि उन्हें "एफ", एक कानूनी ग्रेड मिला है, तो उनकी गलती आपके कोड एक मामले को याद कर रही है?

— माइक ग्रेफ

मुझे इसका हास्य पसंद है, और यह तथ्य कि यह प्रदर्शित करता है कि आप एक मामले में तार का मिलान कर सकते हैं।

— एमरी

Answer 14

आप caseरूबी में दो अलग-अलग तरीकों से अभिव्यक्ति लिख सकते हैं :

1. ifबयानों की एक श्रृंखला के समान
2. लक्ष्य के बगल में एक लक्ष्य निर्दिष्ट करें caseऔर प्रत्येक whenक्लॉज की तुलना लक्ष्य से की गई है।

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

Comments

यद्यपि आपका कोड प्रश्न का उत्तर दे सकता है, आपको कम से कम एक संक्षिप्त विवरण जोड़ना चाहिए कि आपका कोड क्या करता है और यह प्रारंभिक समस्या को कैसे हल करता है।

— user1438038

मैं भविष्य में इस टिप पर विचार करूंगा।

— ysk

Answer 15

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

case expression
when condtion1
   function
when condition2
   function
else
   function
end

Answer 16

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

" रूबी समानता और वस्तु तुलना " विषय पर एक अच्छी चर्चा है।

Comments

संदर्भ के लिए, "स्पेस-शिप" विधि है <=>, जिसका उपयोग क्रमशः -1, 0, 1, या शून्य वापस करने के लिए किया जाता है। रूबी की तुलनात्मक मॉड्यूल प्रलेखन इसे समझाता है।

— टीन मैन

Answer 17

जैसा कि ऊपर दिए गए कई उत्तरों में कहा गया है, ===ऑपरेटर का उपयोग ऑन case/ whenस्टेटमेंट्स के तहत किया जाता है ।

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

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

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

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

वही परिणाम अन्य तरीकों से प्राप्त किया जा सकता है जो संभवतः नौकरी के लिए सबसे उपयुक्त हैं, जैसे कि is_a?और instance_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 का कार्यान्वयन ===

सही पर लौटाता है यदि दाईं ओर का तार बाईं ओर नियमित अभिव्यक्ति से मेल खाता है।

/zen/ === "practice zazen today"  # Output: => true
# is similar to
"practice zazen today"=~ /zen/

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

Answer 18

puts "Recommend me a language to learn?"
input = gets.chomp.downcase.to_s

case input
when 'ruby'
    puts "Learn Ruby"
when 'python'
    puts "Learn Python"
when 'java'
    puts "Learn Java"
when 'php'
    puts "Learn PHP"
else
    "Go to Sleep!"
end

Comments

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

— टिन मैन

Answer 19

$age =  5
case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

अधिक जानकारी के लिए " रूबी - यदि ... और, मामला, जब तक " देखें।

Answer 20

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

a = "secondcase"

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

puts var_name
>> "bar"

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

Comments

इस तरह के कोड को आमतौर पर Hashएक caseबयान के बजाय एक का उपयोग करके किया जाना चाहिए ।

— टॉम

जब वह स्विच बड़ा हो जाता है, तो हैश का उपयोग करना तेज़ होगा।

— टीन मैन

Answer 21

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

[त्रुटि]: असंवैधानिक निरंतर RegExp

पहले से ही यहाँ और यहाँ कवर विधियों के संयोजन के बाद एक वर्कअराउंड :

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वर्ग विधि कथन में s का उपयोग करता हूं क्योंकि ||इसकी पूर्वता अधिक है .include?। यदि आप एक रूबी-नाज़ी हैं , तो कृपया कल्पना करें कि मैंने (item.include? 'A') || ...इसके बजाय इसका उपयोग किया है । repl.it परीक्षण।

Answer 22

,एक whenखंड में अल्पविराम ( ) पर जोर देना महत्वपूर्ण है । यह ||एक ifकथन के रूप में कार्य करता है , अर्थात यह एक OR तुलना करता है औरwhen खंड के सीमांकित अभिव्यक्तियों के बीच AND तुलना नहीं करता है । निम्नलिखित केस स्टेटमेंट देखें:

x = 3
case x
  when 3, x < 2 then 'apple'
  when 3, x > 2 then 'orange'
end
 => "apple"

x2 से कम नहीं है, फिर भी रिटर्न वैल्यू है "apple"। क्यों? क्योंकि x3 था और तब से ',`` acts as an|| , it did not bother to evaluate the expressionx <2 '।

आप सोच सकते हैं कि AND करने के लिए , आप नीचे ऐसा कुछ कर सकते हैं, लेकिन यह काम नहीं करता है:

case x
  when (3 && x < 2) then 'apple'
  when (3 && x > 2) then 'orange'
end
 => nil 

यह क्योंकि काम नहीं करता है (3 && x > 2)सही का आकलन, और रूबी सही मूल्य लेता है और यह तुलना xके साथ ===, जो सच नहीं है, के बाद से x3 है।

एक &&तुलना करने के लिए , आपको caseएक if/ elseब्लॉक की तरह व्यवहार करना होगा :

case
  when x == 3 && x < 2 then 'apple'
  when x == 3 && x > 2 then 'orange'
end

रूबी प्रोग्रामिंग लैंग्वेज बुक में, मैट्स का कहना है कि यह बाद वाला रूप सरल (और आमतौर पर इस्तेमाल किया जाने वाला) रूप है, जो if/ elsif/ के लिए एक वैकल्पिक वाक्यविन्यास से ज्यादा कुछ नहीं है else। हालांकि, चाहे यह आमतौर पर उपयोग किया जाता है या नहीं, मुझे &&दिए गए whenक्लॉज के लिए कई अभिव्यक्तियों को संलग्न करने का कोई अन्य तरीका नहीं दिखता है ।

Comments

यह मुझे अच्छा कोडिंग स्टाइल नहीं लगता है। एक दुर्लभ वैकल्पिक वाक्यविन्यास का उपयोग अनावश्यक रूप से obfuscates। सामान्य उपयोग क्यों नहीं if...elsif? ऐसा लगता है कि आप एक केस स्टेटमेंट और एक शर्त को मिलाने की कोशिश कर रहे हैं। क्यों? बस जब ब्लॉक, जैसे अंदर सशर्त डाल दिया । when 3; ( x < 2 ) ? 'apple' : 'orange'

— sondra.kinsey

Answer 23

हम कई शर्तों के लिए स्विच स्टेटमेंट लिख सकते हैं।

उदाहरण के लिए,

x = 22

CASE x
  WHEN 0..14 THEN puts "#{x} is less than 15"    
  WHEN 15 THEN puts "#{x} equals 15" 
  WHEN 15 THEN puts "#{x} equals 15" 
  WHEN 15..20 THEN puts "#{x} is greater than 15" 
  ELSE puts "Not in the range, value #{x} " 
END

Comments

यह काम नहीं करेगा; रूबी कीवर्ड (जैसे। case, when, end) केस-संवेदी होते हैं और इस तरह अपरकेस नहीं हो सकता।

— sondra.kinsey

NoMethodError (undefined method मामला 'मुख्य: वस्तु) के लिए `। जैसा कि @ sondra.kinsey ने कहा, आप ऊपरी स्थिति का उपयोग नहीं कर सकते। रूबी सोचेंगी यह एक CONSTANT है।

— टिन मैन

Answer 24

caseबयान ऑपरेटर की तरह है switchअन्य भाषाओं में।

यह switch...caseC का वाक्य रचना है:

switch (expression)
​{
    case constant1:
      // statements
      break;
    case constant2:
      // statements
      break;
    .
    .
    .
    default:
      // default statements
}

यह case...whenरूबी में वाक्य रचना है :

case expression
  when constant1, constant2 #Each when statement can have multiple candidate values, separated by commas.
     # statements 
     next # is like continue in other languages
  when constant3
     # statements 
     exit # exit is like break in other languages
  .
  .
  .
  else
     # statements
end

उदाहरण के लिए:

x = 10
case x
when 1,2,3
  puts "1, 2, or 3"
  exit
when 10
  puts "10" # it will stop here and execute that line
  exit # then it'll exit
else
  puts "Some other number"
end

अधिक जानकारी के लिए caseदस्तावेज़ीकरण देखें ।