有没有比使用自定义的case语句更有用的方法来在Ruby中编写它？

Question

想象一下下面的代码：

class SimpleLetter 
    def values 
    ("a" .. "z").to_a 
    end 

    def ===(other) 
    values.include?(other) 
    end 
end 

class Vowel < SimpleLetter 
    def values 
    ["a","e","i","o","u"] 
    end 
end 

class Consonant < SimpleLetter 
    def values 
    super - Vowel.new.values 
    end 
end 

objects = ("a" .. "f").to_a + (1 .. 5).to_a 

objects.each do |letter| 
    case letter 
    when Vowel.new 
     puts "#{letter} it's a vowel" 
    when Consonant.new 
     puts "#{letter} it's a consonant" 
    else 
     puts "#{letter} it's something else" 
    end 
end 

我可以选择任何其他类，而不是，我只是用它们作为一个例子。我非常喜欢Scala的match和提取器，我认为这可能是在Ruby中编写相同的东西的一种很好的方式。有没有更好的方式来写上述，而不必实例化新的对象，所以我可以调用他们的===方法？

只是为了避免不必要的岗位，是的，我知道我能做到这一点：

case letter 
    when ["a","e","i","o","u"].include?(letter) 
    # ... 
end 

Answer 1

你可以使用类方法而不是实例方法：

class SimpleLetter 
    def self.values 
     ("a" .. "z").to_a 
    end 

    def self.===(other) 
     values.include?(other) 
    end 
end 

class Vowel < SimpleLetter 
    def self.values 
     ["a","e","i","o","u"] 
    end 
end 

class Consonant < SimpleLetter 
    def self.values 
     super - Vowel.values 
    end 
end 

objects = ("a" .. "f").to_a + (1 .. 5).to_a 

objects.each do |letter| 

    case letter 
     when Vowel 
      puts "#{letter} it's a vowel" 
     when Consonant 
      puts "#{letter} it's a consonant" 
     else 
      puts "#{letter} it's something else" 
    end 

end 

Answer 2

你不需要上课那些角色。将它们设置为数组，并在case语句中使用splat运算符。

SimpleLetter = ("a" .. "z").to_a 
Vowel  = %w[a e i o u] 
Consonant = SimpleLetter - Vowel 

(("a" .. "f").to_a + (1 .. 5).to_a).each do |letter| 
    case letter 
    when *Vowel 
     puts "#{letter} it's a vowel" 
    when *Consonant 
     puts "#{letter} it's a consonant" 
    else 
     puts "#{letter} it's something else" 
    end 
end 

Answer 3

===作品上的块，太：

Letters = ('a'..'z').to_a 
Vowels = ['a','e','i','o','u'] 
Consonants = Letters - Vowels 

Vowel = lambda { |x| Vowels.include? x } 
Consonant = lambda { |x| Consonants.include? x } 

objects = ("a" .. "f").to_a + (1 .. 5).to_a 

objects.each do |object| 
    case object 
    when Vowel 
     puts "#{object} is a vowel." 
    when Consonant 
     puts "#{object} is a consonant." 
    else 
     puts "#{object} is an object." 
    end 
end 

Answer 4

你已经有几个很好的答案（如泽的），所以我包括一个玩票一个没有case声明：

SIMPLE_LETTER = [*"a" .. "z"] 
VOWEL  = %w[a e i o u] 
CONSONANT = SIMPLE_LETTER - VOWEL 

[*?a..?f,*1..5].each do |letter| 
    letter_class = %w(vowel consonant).select { |c| Object.const_get(c.upcase).include? letter}.first 
    puts "'#{letter}': #{ letter_class || "something else"}" 
end 

输出：

'a': vowel 
'b': consonant 
'c': consonant 
'd': consonant 
'e': vowel 
'f': consonant 
'1': something else 
'2': something else 
'3': something else 
'4': something else 
'5': something else 

多图示和字符文字只能在1.9中使用。

Answer 5

你让我困惑的代码，因为SimpleLetter应该是单个字母，而不是整个字母表。

我会都特别想做到以下几点，尽管是的monkeypatching一个有点冒险：

module Voweliness 
    def vowel? 
    self =~ /[aeiou]/i 
    end 

    def consonant? 
    (self =~ /[a-z]/i and not vowel?) 
    end 
end 

class String 
    include Voweliness 
end 


objects.each do |letter| 
    case 
    when letter.vowel? 
     puts "#{letter} is a vowel" 
    when letter.consonant? 
     puts "#{letter} is a consonant" 
    else 
     puts "#{letter} is something else" 
    end 
end