Двоичный или "|" в рубине

Question

Почему это не работает:

>> s = "hi"                                                             
=> "hi"                                                                 
>> s == ("hi"|"ho")                                                     
NoMethodError: undefined method `|' for "hi":String                     
 from (irb):2                                                           
>>

Я не понимаю .. Есть ли решение для такого типа синтаксиса? Поскольку

s == ("hi"|"ho") 
#is shorther than 
s == "hi" || s == "ho"

Answer 1

Да, побитовый оператор | не определено в классе String: http://ruby -doc.org / core / classes / String.html

Рассмотрим это для выразительности:

["hi", "ho"].include? myStr

irb(main):001:0> s = "hi"
=> "hi"
irb(main):002:0> ["hi", "ho"]
=> ["hi", "ho"]
irb(main):003:0>  ["hi", "ho"].include? s
=> true
irb(main):004:0> s = "foo"
=> "foo"
irb(main):005:0>  ["hi", "ho"].include? s
=> false

Answer 2

В большинстве языков высокого уровня этот синтаксис не работает, вы должны придерживаться более длинного синтаксиса:

s == "привет" || s == "хо"

Обратите внимание, что | является побитовым или, тогда как || это обычный или

Answer 3

Вы можете использовать метод include? в массиве, если у вас есть несколько == тестов:

["hi", "ho"].include?(s)

Правда, не короче для двух проверок, но будет короче для трех и более.

Answer 4

Насколько я знаю, этот синтаксис не существует ни на одном языке.

Что вы говорите

s == ("hi"|"ho")

Буквально переводит в 'побитовое ИЛИ строки' hi 'и' ho 'вместе, а затем сравнивает их с s'. Если вы не понимаете, почему это не то, что вам нужно, попробуйте записать коды ASCII для «hi» и «ho», а затем побитово ИЛИ их вместе. Вы получите полную тарабарщину.

Answer 5

Ruby поддерживает двоичные 'или' и другие двоичные операции для значений типа Fixnum и Bignum, что означает любое целое число. Насколько я знаю, побитовые операции не поддерживаются со строками или любыми другими типами.

Как уже упоминали другие люди, вы, вероятно, вообще хотите что-то, кроме бинарных операций. Тем не менее, вы можете легко получить целочисленные представления символов, поэтому вы можете сравнивать символы следующим образом:

a = "Cake"
b = "Pie"
puts a[0] | b[0] # Prints "83" - C is 67 and P is 80.

Вы можете легко получить массив сравнений с некоторыми преобразованиями.

a = "Cake"
b = "Pie " # Strings of uneven length is trivial but more cluttered.

a_arr = a.split(//)
b_arr = b.split(//)
c_arr = []

a.each_with_index { |char, i| c.push(a[i].to_i | b[i].to_i) }
# If you *really* want an ASCII string back...
c = c_arr.collect(&:chr).join

Answer 6

Вы можете заставить это работать таким образом:

irb> class Pair
       def initialize(strA,strB)
         @strA,@strB = strA,strB
       end
       def ==(string)
         string == @strA || string == @strB
       end
       def |(other)
         Pair.new(self,other)
       end
     end
#=> nil
irb> class String
       def |(other)
         Pair.new(self,other)
       end
       alias old_equals :==
       def ==(other)
         if other.kind_of? Pair
           other == self
         else
           old_equals other
         end
       end
     end
#=> nil
irb> ("one"|"two") == "one"
#=> true
irb> ("one"|"two") == "two"
#=> true
irb> ("one"|"two") == "three"
#=> false
irb> "one" == ("one"|"two")
#=> true
irb> "three" == ("one"|"two"|"three")
#=> true

Но так как это включает в себя некоторые исправления довольно низкого уровня, я бы не советовал полагаться на это. Другие люди будут ненавидеть читать ваш код.

Answer 7

Вы можете использовать регулярное выражение:

Вроде так:

regex = /hi|ho/
s = "hi"
t = "foo"

s =~ regex
#=> 0

t =~ regex
#=> nil