Risposte:
andè uguale &&ma con precedenza inferiore . Entrambi usano la valutazione del corto circuito .
ATTENZIONE: andha anche una precedenza inferiore rispetto a quella =che di solito vorrai evitare and. Un esempio di andutilizzo dovrebbe essere trovato nella Guida Rails in " Evitare errori di doppio rendering ".
&&, mentre anddovrebbe essere usato solo per casi molto specifici.
and è come un ifmodificatore di dichiarazione invertito : next if widget = widgets.popdiventa widget = widgets.pop and next. È un ottimo modo per dirlo, in realtà lo ha" fatto clic "nella mia testa (ed orè come un unlessmodificatore invertito ).
La differenza pratica è la forza vincolante, che può portare a comportamenti peculiari se non sei preparato per questo:
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
# => :fooLa stessa cosa funziona per ||e or.
a = foo and bar e (a = foo ) && bar dimostra che andha una precedenza inferiore a &&.
a = foo and barè equivalente a (a = :foo) and nil. Poiché l'assegnazione restituisce un valore logicamente vero ( :foo), viene valutata la seconda parte, che non riesce, restituendo nil.
La Guida allo stile Ruby lo dice meglio di quanto potrei:
Usa && / || per espressioni booleane e / o per flusso di controllo. (Regola empirica: se devi usare parentesi esterne, stai usando gli operatori sbagliati.)
# boolean expression
if some_condition && some_other_condition
do_something
end
# control flow
document.saved? or document.save!and/ orcompletamente, e potrebbero avere un punto. Spesso il loro utilizzo nel flusso di controllo potrebbe essere più ovviamente scritto con if/ unlessoperatori (ad es. document.save! unless document.saved?)
||e &&legare con la precedenza che ci si aspetta dagli operatori booleani nei linguaggi di programmazione ( &&è molto forte, ||è leggermente meno forte).
and e or hanno una precedenza inferiore.
Ad esempio, a differenza di ||, orha una precedenza inferiore a =:
> a = false || true
=> true
> a
=> true
> a = false or true
=> true
> a
=> falseAllo stesso modo, a differenza &&, andha anche una precedenza inferiore rispetto a =:
> a = true && false
=> false
> a
=> false
> a = true and false
=> false
> a
=> true Cosa c'è di più, a differenza di &&e ||, ande orlegare con uguale precedenza:
> !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
=> trueIl debolmente vincolante ande orpuò essere utile ai fini del flusso di controllo: vedi http://devblog.avdi.org/2010/08/02/using-and-and-or-in-ruby/ .
||, orha una precedenza inferiore rispetto a =" ... ora ha più senso, grazie!
andha una precedenza inferiore a &&.
Ma per un utente senza pretese, potrebbero verificarsi problemi se viene utilizzato insieme ad altri operatori la cui precedenza è tra, ad esempio, l'operatore di assegnazione:
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
# => trueandha una precedenza inferiore, principalmente lo usiamo come modificatore del flusso di controllo come if:
next if widget = widgets.popdiventa
widget = widgets.pop and nextPer or:
raise "Not ready!" unless ready_to_rock?diventa
ready_to_rock? or raise "Not ready!"Preferisco usare ifma non and, perché ifè più intelligibile, quindi ignoro ande or.
Fare riferimento a " Utilizzo di" e "e" o "in Ruby " per ulteriori informazioni.
Non so se questa è l'intenzione di Ruby o se questo è un bug, ma prova questo codice qui sotto. Questo codice è stato eseguito su Ruby versione 2.5.1 ed era su un sistema Linux.
puts 1 > -1 and 257 < 256
# => false
puts 1 > -1 && 257 < 256
# => true
ore||.