Diferença entre "e" e && em Ruby?

Qual é a diferença entre the &&e andoperadores no Ruby?

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 ".

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
# => :foo

A mesma coisa funciona para ||e or.

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!

||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
 => false

Da 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
 => true

A 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/ .

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
# => true

andtem precedência mais baixa, principalmente o usamos como um modificador de controle-fluxo, como if:

next if widget = widgets.pop

torna-se

widget = widgets.pop and next

Para 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