switchරූබි භාෂාවෙන් ප්‍රකාශයක් ලියන්නේ කෙසේද ?

රූබි ඒ වෙනුවට 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.

whenඉහත දැක්වෙන පරිදි නවීන වගන්ති සඳහා මෙය ඉඩ දෙයි . පරාසය, පංති සහ සියලු ආකාරයේ දේවල් සමානාත්මතාවයට වඩා පරීක්ෂා කළ හැකිය.

මෙන් නොව switchතවත් බොහෝ භාෂා වලින් ප්රකාශ, රූබි ගේ caseනැත වැටීම-හරහා , ඒ නිසා එක් එක් අවසන් කිරීමට අවශ්යතාවයක් නැත whenසමග break. whenවැනි එක වගන්තියකින් ඔබට බහුවිධ ගැලපීම් නියම කළ හැකිය when "foo", "bar".

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

පිළිතුරක් සොයන අතරතුර මම අද මෙම ගැටලුවට මුහුණ දුන් අතර, මෙය පළමුවෙන්ම දිස්වන පිටුව වන බැවින් මගේ තත්වය තුළම එය අනෙක් අයටද ප්‍රයෝජනවත් වනු ඇතැයි මම සිතුවෙමි.

එය 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

මගේ කින්ඩල්හි රූබි ක්‍රමලේඛන භාෂාවේ (1 වන සංස්කරණය, ඕ'රෙයිලි) 123 වන පිටුවේ , එහි thenසඳහන් වන්නේ whenවගන්ති අනුගමනය කරන මූල පදය නව රේඛාවක් හෝ අර්ධ සළකුණක් සමඟ ප්‍රතිස්ථාපනය කළ හැකි බවයි ( if then elseවාක්‍ය ඛණ්ඩයේ මෙන් ). (රූබි 1.8 ද කොලොන් වෙනුවට තැනීමට ඉඩ දෙයි then, නමුත් මෙම සින්ටැක්ස් රූබි 1.9 හි තවදුරටත් ඉඩ නොදේ.)

නඩුව ... කවදාද

චක්ගේ පිළිතුරට තවත් උදාහරණ එක් කිරීමට :

පරාමිතිය සමඟ:

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

කරුණාකර, කිකිටෝ අනතුරු අඟවන " රූබි හි ස්විච් ප්‍රකාශයක් ලියන්නේ කෙසේද " යන්න ගැන සැලකිලිමත් වන්න.

බොහෝ ක්‍රමලේඛන භාෂාවන්ට, විශේෂයෙන් සී වෙතින් ලබාගත් ඒවාට ඊනියා ස්විච් වැටීම සඳහා සහය ඇත. මම රූබි භාෂාවෙන් එය කිරීමට හොඳම ක්‍රමය සොයමින් සිටි අතර එය අන් අයට ප්‍රයෝජනවත් වේ යැයි සිතුවෙමි:

සී වැනි භාෂාවලින් පහත වැටීම සාමාන්‍යයෙන් මේ වගේ ය:

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', නමුත් බොහෝ දුරට එය එකම ආකාරයකින් ප්‍රයෝජනවත් වීමට තරම් සමාන බව මට පෙනේ.

රූබි 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 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 උදාහරණය භාවිතා කරමින් මෙය කළ හැකිය (පරාමිතිය නොමැතිව), මෙම ප්‍රවේශය සඳහා වඩා පිරිසිදු වන්නේ මෙම ප්‍රවේශය පමණි.

රූබි ස්විච් නඩුවකදී OR තත්වයක් භාවිතා කරන්නේ කෙසේදැයි දැන ගැනීමට ඔබ උනන්දු වන්නේ නම්:

ඒ නිසා, දී caseප්රකාශයක්, එය ,සමාන වේ ||තුළ සිටින ifප්රකාශයක්.

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

" රූබි සිද්ධි ප්‍රකාශයක් ක්‍රියාත්මක වන ආකාරය සහ ඔබට එය සමඟ කළ හැකි දේ " බලන්න.

එය කැඳවනු ලබන 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

රූබි 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

ඔබගේ නඩුව මත පදනම්ව, ඔබට ක්‍රම හෑෂ් භාවිතා කිරීමට කැමති විය හැකිය.

whenS හි දීර් list ලැයිස්තුවක් තිබේ නම් සහ ඒ සෑම එකක්ම සංසන්දනය කිරීම සඳහා සංයුක්ත අගයක් තිබේ නම් (කාල පරතරයක් නොවේ), එය ක්‍රම හෑෂ් එකක් ප්‍රකාශ කිරීම වඩාත් effective ලදායී වනු ඇති අතර පසුව ඒ හා සමාන ක්‍රමවේදය හැෂ් වෙතින් අමතන්න.

# 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])

switch caseසෑම විටම තනි වස්තුවක් ආපසු ලබා දෙන බැවින් , අපට එහි ප්‍රති result ලය කෙලින්ම මුද්‍රණය කළ හැකිය:

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

වටිනාකමක් නොමැති විට සහ අගය නොමැති බහු-අගය:

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

ඔබට 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

ඔබට මෙය වඩාත් ස්වාභාවික ආකාරයකින් කළ හැකිය,

case expression
when condtion1
   function
when condition2
   function
else
   function
end

හොඳ පිළිතුරු රාශියක් ඇති නමුත් මම සිතුවේ මම එක් ෆැක්ටෝයිඩ් එකක් එකතු කරමි .. ඔබ වස්තූන් (පන්ති) සංසන්දනය කිරීමට උත්සාහ කරන්නේ නම් ඔබට අභ්‍යවකාශ නැව් ක්‍රමයක් (විහිළුවක් නොවේ) ඇති බවට වග බලා ගන්න හෝ ඒවා සංසන්දනය කරන්නේ කෙසේද යන්න තේරුම් ගන්න

" රූබි සමානාත්මතාවය සහ වස්තු සංසන්දනය " යනු මාතෘකාව පිළිබඳ හොඳ සාකච්ඡාවකි.

ඉහත බොහෝ පිළිතුරු වල සඳහන් කර ඇති පරිදි, ===ක්‍රියාකරු භාවිතා කරනුයේ හුඩ් ඔන් 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/

ඉහත උදාහරණ දෙක අතර ඇති එකම අදාළ වෙනස නම්, ගැලපීමක් ඇති විට, ===සත්‍යය =~වෙත ආපසු ගොස් පූර්ණ සංඛ්‍යාවක් ආපසු ලබා දීමයි, එය රූබි හි සත්‍ය වටිනාකමකි. අපි ඉක්මනින් මේ වෙත නැවත පැමිණෙමු.

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

$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

වැඩි විස්තර සඳහා " රූබි - නම් ... වෙනත්, නඩුව, හැර " බලන්න.

මම භාවිතා කිරීමට පටන් ගෙන ඇත:

a = "secondcase"

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

puts var_name
>> "bar"

එය සමහර අවස්ථාවල සංයුක්ත කේතයට උපකාරී වේ.

ඔබේ පරිසරයේ නිත්‍ය ප්‍රකාශන සඳහා සහය නැද්ද? උදා: Shopify Script Editor (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 පරීක්ෂණය.

වගන්තියකින් කොමාව ( ,) අවධාරණය කිරීම ඉතා වැදගත්ය when. එය ලෙස ක්රියා ||ක ක ifඑය කරන්නේ, බව, ප්රකාශ හෝ සසඳා නොවන සහ ම පිරිසගේ ප්රකාශන අතර සැසඳීමක් whenවගන්තිය. පහත දැක්වෙන සිද්ධි ප්‍රකාශය බලන්න:

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සමඟ සංසන්දනය කරයි ===, එය සත්‍ය නොවන බැවින්x 3 වේ.

ක කරන්න &&සංසන්දනය, ඔබ ප්රතිකාර කිරීම සිදු වනු ඇත caseයනු වැනි if/ elseවාරණ:

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

රූබි ක්‍රමලේඛන භාෂා පොතේ, මැට්ස් පවසන්නේ මෙම දෙවන ආකෘතිය සරල (හා කලාතුරකින් භාවිතා කරන) ආකෘතිය වන අතර එය if/ elsif/ සඳහා විකල්ප වාක්‍ය ඛණ්ඩයකට වඩා වැඩි දෙයක් නොවන elseබවයි. කෙසේ වෙතත්, එය කලාතුරකින් භාවිතා කළත් නැතත්, &&දී ඇති whenවගන්තියක් සඳහා බහු ප්‍රකාශන ඇමිණීමට වෙනත් ක්‍රමයක් මා දකින්නේ නැත .

අපට විවිධ කොන්දේසි සඳහා ස්විච් ප්‍රකාශය ලිවිය හැකිය.

උදාහරණයක් වශයෙන්,

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

මෙම 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ප්‍රලේඛනය බලන්න .