Respostas:
andé o mesmo que &&mas com menor precedência . Ambos usam avaliação de curto-circuito .
AVISO: andainda tem precedência mais baixa do que =você normalmente deseja evitar and. Um exemplo de quando anddeve ser usado pode ser encontrado no Guia do Rails, em " Evitando erros de renderização dupla ".
&&, enquanto anddeve ser usado apenas para casos muito específicos.
andé como um ifmodificador de declaração invertida : next if widget = widgets.poptorna - se widget = widgets.pop and next. Essa é uma ótima maneira de colocar isso, realmente fez com que" clique "na minha cabeça. (E oré como um unlessmodificador invertido .)
A diferença prática é a força de ligação, que pode levar a um comportamento peculiar se você não estiver preparado para isso:
foo = :foo
bar = nil
a = foo and bar
# => nil
a
# => :foo
a = foo && bar
# => nil
a
# => nil
a = (foo and bar)
# => nil
a
# => nil
(a = foo) && bar
# => nil
a
# => :fooA mesma coisa funciona para ||e or.
a = foo and bar e (a = foo ) && bar prova que andtem precedência menor que &&.
a = foo and baré equivalente a (a = :foo) and nil. Como a atribuição retorna um valor logicamente verdadeiro ( :foo), a segunda parte avalia, o que falha, retornando nil.
O Ruby Style Guide diz que é melhor do que eu poderia:
Use && / || para expressões booleanas e / ou para controle de fluxo. (Regra básica: se você precisar usar parênteses externos, estará usando os operadores errados.)
# boolean expression
if some_condition && some_other_condition
do_something
end
# control flow
document.saved? or document.save!and/ orcompletamente, e eles podem ter razão . Muitas vezes, a sua utilização no controlo de fluxo pode ser mais obviamente escrito com if/ unlessoperadores de qualquer forma (por exemplo, document.save! unless document.saved?)
||e &&vincule com a precedência que você espera dos operadores booleanos nas linguagens de programação ( &&é muito forte, ||é um pouco menos forte).
and e or têm menor precedência.
Por exemplo, ao contrário ||, ortem precedência mais baixa que =:
> a = false || true
=> true
> a
=> true
> a = false or true
=> true
> a
=> falseDa mesma forma, ao contrário &&, andtambém tem precedência menor do que =:
> a = true && false
=> false
> a
=> false
> a = true and false
=> false
> a
=> true Além do mais, ao contrário &&e ||, ande orse ligam com a mesma precedência:
> !puts(1) || !puts(2) && !puts(3)
1
=> true
> !puts(1) or !puts(2) and !puts(3)
1
3
=> true
> !puts(1) or (!puts(2) and !puts(3))
1
=> trueA ligação fraca ande orpode ser útil para fins de controle de fluxo: consulte http://devblog.avdi.org/2010/08/02/using-and-and-or-in-ruby/ .
||, ortem precedência menor que =" ... agora faz mais sentido, obrigado!
andtem precedência mais baixa que &&.
Mas para um usuário despretensioso, podem ocorrer problemas se ele for usado junto com outros operadores cuja precedência esteja entre, por exemplo, o operador de atribuição:
def happy?() true; end
def know_it?() true; end
todo = happy? && know_it? ? "Clap your hands" : "Do Nothing"
todo
# => "Clap your hands"
todo = happy? and know_it? ? "Clap your hands" : "Do Nothing"
todo
# => trueandtem precedência mais baixa, principalmente o usamos como um modificador de controle-fluxo, como if:
next if widget = widgets.poptorna-se
widget = widgets.pop and nextPara or:
raise "Not ready!" unless ready_to_rock?torna-se
ready_to_rock? or raise "Not ready!"Eu prefiro usar, ifmas não and, porque ifé mais inteligível, então simplesmente ignoro ande or.
Consulte " Usando" e "e" ou "em Ruby " para obter mais informações.
Não sei se essa é a intenção do Ruby ou se é um bug, mas tente este código abaixo. Este código foi executado no Ruby versão 2.5.1 e estava em um sistema Linux.
puts 1 > -1 and 257 < 256
# => false
puts 1 > -1 && 257 < 256
# => true
ore||.