Как лучше всего справиться с этим типом инклюзивной логики в Ruby?

Question

Есть ли лучший способ справиться с этим в Ruby, продолжая использовать символы?

pos = :pos1 # can be :pos2, :pos3, etc.

if pos == :pos1 || pos == :pos2 || pos == :pos3
  puts 'a'
end

if pos == :pos1 || pos == :pos2
  puts 'b'
end

if pos == :pos1
  puts 'c'
end

Очевидным способом было бы заменить символы на числовые константы, но это не вариант.

pos = 3

if pos >= 1
  puts 'a'
end

if pos >= 2
  puts 'b'
end

if pos >= 3
  puts 'c'
end

Спасибо.

EDIT Я только что понял, что Ruby упорядочивает символы в алфавитном / числовом порядке.Это работает отлично.

pos = :pos2 # can be :pos2, :pos3, etc.

if pos >= :pos1
  puts 'a'
end

if pos >= :pos2
  puts 'b'
end

if pos >= :pos3
  puts 'c'
end

Answer 1

Просто используйте оператор case

pos = :pos1 # can be :pos2, :pos3, etc.

case pos
   when :pos1 then %w[a b c]
   when :pos2 then %w[a b]
   when :pos3 then %w[a]
end.each {|x| puts x }

Answer 2

Не уверен, что это лучший способ ......

Я бы использовал метод include? из массива:

puts 'a' if [:pos1, :pos2, :pos3].include? pos
puts 'b' if [:pos1, :pos2].include? pos
puts 'c' if [:pos1].include? pos

Answer 3

Есть много разных способов получить результат. Какой ты желание зависит от ваших конкретных возражений против ваших if заявлений. Я добавил кучу дополнительного форматирования, чтобы облегчить вывод читать.

Если вам не нравятся логические ИЛИ и то, как они разделяют результаты из вывода вы можете использовать справочную таблицу:

puts "Lookup table 1:"
lookup_table1 = {
    :pos1 => %w{a b c},
    :pos2 => %w{a b  },
    :pos3 => %w{a    },
}
[:pos1, :pos2, :pos3].each { |which|
    puts "\t#{which}"
    lookup_table1[which].each { |x| puts "\t\t#{x}" }
}

Или, если вам нужна вся «работа» в таблице поиска:

puts "Lookup table 2:"
lookup_table2 = {
    :pos1 => lambda do %w{a b c}.each { |x| puts "\t\t#{x}" } end,
    :pos2 => lambda do %w{a b  }.each { |x| puts "\t\t#{x}" } end,
    :pos3 => lambda do %w{a    }.each { |x| puts "\t\t#{x}" } end,
}
[:pos1, :pos2, :pos3].each { |which|
    puts "\t#{which}"
    lookup_table2[which].call
}

Если ваша проблема в том, что символы не являются порядковыми, то вы можете упорядочить их, преобразовав их в строки:

puts "Ordinals by .to_s and <="
[:pos1, :pos2, :pos3].each { |which|
    puts "\t#{which}"
    if which.to_s <= :pos3.to_s
        puts "\t\ta"
    end
    if which.to_s <= :pos2.to_s
        puts "\t\tb"
    end
    if which.to_s <= :pos1.to_s
        puts "\t\tc"
    end
}

Или вы могли бы обезьяна вставить оператор сравнения в символ класс (не рекомендуется):

puts "Ordinals by Symbol#<="
class Symbol
    def <= (x)
        self.to_s <= x.to_s
    end
end
[:pos1, :pos2, :pos3].each { |which|
    puts "\t#{which}"
    if which <= :pos3
        puts "\t\ta"
    end
    if which <= :pos2
        puts "\t\tb"
    end
    if which <= :pos1
        puts "\t\tc"
    end
}

Или вы можете использовать справочную таблицу для указания ваших порядковых значений:

puts "Ordinals through a lookup table:"
ordinal = {
    :pos1 => 1,
    :pos2 => 2,
    :pos3 => 3,
}
[:pos1, :pos2, :pos3].each { |which|
    puts "\t#{which}"
    if ordinal[which] <= 3
        puts "\t\ta"
    end
    if ordinal[which] <= 2
        puts "\t\tb"
    end
    if ordinal[which] <= 1
        puts "\t\tc"
    end
}

Это очевидные из головы. Трудно сказать, что было бы лучше, если бы не уточняли, в чем заключается ваша проблема с вашим подходом if; Ваш второй пример показывает, что на самом деле вам нужен способ превратить символы в порядковые.

Answer 4

В более общем смысле, вы можете использовать это:

pos = :pos3
arr = [:pos1,:pos2,:pos3]
curr = 'a'

idx = arr.length
while idx > 0
  puts curr if arr.last(idx).include? pos
  curr = curr.next
  idx -= 1
end

Или это, для вашего конкретного примера:

puts 'a'
puts 'b' if pos != :pos3
puts 'c' if pos == :pos1