如何在Ruby中编写switch语句

在Ruby中,可以通过以下方式实现:

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',但是在大多数情况下我发现它类似于以相同的方式有用.

在Ruby 2.0中,您还可以在case语句中使用lambdas ,如下所示:

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

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

您还可以使用带有自定义的Struct轻松创建自己的比较器 ===

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

(示例摘自" 可以在Ruby 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

(示例摘自" Ruby案例陈述如何工作以及您可以用它做什么 ".)

您可以使用正则表达式,例如查找字符串类型:

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

Ruby case将使用相等操作数===(感谢@JimDeville).有关更多信息,请访问" Ruby Operators ".这也可以使用@mmdemirbas示例(不带参数)来完成,只有这种方法对于这些类型的情况更清晰.

如果您渴望知道如何在Ruby switch案例中使用OR条件:

因此,在一个case声明中,a ,等同||于if声明.

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

您可以使用Ruby案例语句执行许多其他操作

它被称为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参数并只写出第一个匹配所需的表达式来替换任意的if/else链(即,即使测试不涉及公共变量).

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

根据您的情况,您可能更喜欢使用方法哈希.

如果有一个很长的时间列表,并且每个都有一个具体值要与之比较(而不是间隔),那么声明方法的散列然后从这样的散列调用相关方法会更有效.

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

Ruby使用casefor来编写switch语句.

根据Ruby Docs:

case语句由一个可选条件组成,该条件位于参数的位置case,以及零个或多个case子句.when匹配条件的第一个子句(或者,如果条件为null,则评估为布尔真值)"wins",并执行其代码节.case语句的值是success when子句的值,或者when如果没有这样的子句.

案例陈述可以以nil条款结束.每个else语句可以有多个候选值,以逗号分隔.

例:

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撰写的这篇博客描述的Ruby Case;

可以与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!"

可以与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

由于switch case始终返回单个对象,我们可以直接打印其结果:

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

您可以在ruby中以两种不同的方式编写案例表达式.

类似于一系列"if"语句

指定案例旁边的目标,并将每个"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

很多很好的答案,但我想我会添加一个factoid ..如果你试图比较对象(类)确保你有一个太空船方法(不是一个笑话)或理解他们如何被比较

以下是关于该主题的一个很好的讨论 http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

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

如以上许多答案所述，===运算符用于case/ when语句的内幕。

这是有关该运算符的其他信息：

大小写相等运算符： ===

Ruby的许多内置类，例如String，Range和Regexp，提供了它们自己的===运算符实现，也称为“大小写相等”，“三重相等”或“三重相等”。由于在每个类中实现的方式不同，因此根据调用对象的类型，其行为也将有所不同。通常，如果右侧的对象“属于”左侧的对象或属于左侧的对象，则返回true。例如，它可以用来测试一个对象是否是一个类（或其子类之一）的实例。

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

使用其他可能最适合此工作的方法（例如is_a?和）可以达到相同的结果instance_of?。

范围执行 ===

在===范围对象上调用运算符时，如果右侧的值落在左侧的范围内，则返回true。

(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。换句话说，左侧操作数的类将定义===将调用该方法的哪种实现，因此操作数位置不可互换。

正则表达式的实现 ===

如果右侧的字符串与左侧的正则表达式匹配，则返回true。

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

上面两个示例之间唯一相关的区别是，如果存在匹配项，则===返回true并=~返回一个整数，这是Ruby中的真值。我们将尽快回到这一点。