正如上面的许多答案中所述，在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。换句话说，左侧操作数的类将定义将调用==方法的哪个实现，因此操作数位置不可互换。

Regexp的实现===

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

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

上面两个示例之间唯一相关的区别是，当存在匹配时，==返回true，而==返回整数，这在Ruby中是一个真值。我们很快就会回来讨论这个问题。

案例什么时候

为Chuck的答案添加更多示例：

使用参数：

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

请注意kikito警告的“如何在Ruby中编写switch语句”。

我们可以为多个条件编写switch语句。

例如

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

在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中，procs可以与case语句一起使用吗？”。）

或者，对于完整的类：

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语句的工作原理和使用它可以做什么”。）

如果您需要“小于”或“大于”：

case x
when 1..5
  "It's between 1 and 5"
when 6
  "It's 6"
when 7..1.0/0
  "It's equal or greater than 7"
when -1.0/0..0
  "It's equal or less than 0"
end

1.0/0等于Float:：INFINITY，因此您可以使用自己喜欢的。

在Ruby 2.6之后，您可以使用Endless Ranges，在Ruby 2.7之后，您还可以使用Beginless Ranges，例如：

case x
when 1..5
  "It's between 1 and 5"
when 6
  "It's 6"
when (7..)
  "It's equal or greater than 7"
when (..0)
  "It's equal or less than 0"
end

许多编程语言，特别是源于C的语言，都支持所谓的Switch Fallthrough。我正在寻找在Ruby中实现这一点的最佳方法，并认为这可能对其他人有用：

在类C语言中，故障通常如下所示：

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;
}

在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”之前执行一块代码，但在大多数情况下，我发现它足够相似，以同样的方式有用。