Quelle est la différence entre le or
et le ||
opérateurs en Ruby? Ou est-ce juste une préférence?
C'est une question de priorité des opérateurs.
||
a une priorité supérieure à or
.
Donc, entre les deux, vous avez d'autres opérateurs, y compris ternaire (? :
) et affectation (=
) Ainsi, celui que vous choisissez peut affecter le résultat des déclarations.
Voici un tableau de priorité des opérateurs Ruby .
Voir cette question pour un autre exemple utilisant and
/&&
.
De plus, soyez conscient de certaines choses désagréables qui pourraient arriver:
a = false || true #=> true
a #=> true
a = false or true #=> true
a #=> false
Les deux instructions précédentes sont évaluées à true
, mais la seconde définit a
à false
depuis =
la précédence est inférieure à ||
mais supérieur à or
.
Comme les autres l’ont déjà expliqué, la différence seulement est la priorité. Cependant, je voudrais souligner qu’il existe en réalité deux différences entre les deux:
and
, or
et not
ont beaucoup une priorité inférieure à &&
, ||
et !
and
et or
ont la priorité identique, alors que &&
a plus élevé précédent que ||
En général, il vaut mieux éviter d'utiliser and
, or
et not
et d'utiliser &&
, ||
Et !
À la place. (Les développeurs Rails, par exemple, rejettent les correctifs qui utilisent les formes de mot-clé au lieu des formes d'opérateur.)
La raison pour laquelle ils existent, ce n'est pas pour les formules booléennes, mais pour le contrôle du flux. Ils se frayèrent un chemin dans Ruby via l'idiome bien connu de do_this or do_that
De Perl, où do_this
Renvoie false
ou nil
si il y a une erreur et seulement alors est do_that
exécuté à la place. (Analogue, il y a aussi l'idiome do_this and then_do_that
.)
Exemples:
download_file_via_fast_connection or download_via_slow_connection
download_latest_currency_rates and store_them_in_the_cache
Parfois, cela peut rendre le flux de contrôle un peu plus fluide que d'utiliser if
ou unless
.
Il est facile de comprendre pourquoi, dans ce cas, les opérateurs ont la "fausse" priorité (c'est-à-dire identiques): ils ne s'affichent jamais ensemble dans la même expression. Et quand ils font se présentent ensemble, vous voulez ils doivent être évalués simplement de gauche à droite.
et/ou sont pour le contrôle du flux.
Ruby n'autorisera pas cela en tant que syntaxe valide:
false || raise "Error"
Cependant ceci est valable:
false or raise "Error"
Vous pouvez faire le premier travail avec () mais utiliser or
est la bonne méthode.
false || (raise "Error")
puts false or true
-> empreintes: false
puts false || true
-> empreintes: true
La façon dont j'utilise ces opérateurs:
||, &&
sont pour la logique booléenne. or, and
sont pour le contrôle de flux. Par exemple.
do_smth if may_be || may_be
- nous évaluons la situation ici
do_smth or do_smth_else
- nous définissons le flux de travail, ce qui équivaut à do_smth_else unless do_smth
pour donner un exemple simple:
> puts "a" && "b" b
> puts 'a' and 'b' a
Un idiome connu dans Rails est render and return
. C'est un raccourci pour dire return if render
, tandis que render && return
ne fonctionnera pas (voir Rails documentation )
ou n'est pas identique à
Utiliser seulement || opérateur au lieu de o opérateur.
Les raisons :
Les deux "ou" et "||" Évaluez true si l'un des opérandes est vrai. Ils évaluent leur deuxième opérande seulement si le premier est faux.
Comme avec "et", la seule différence entre "ou" et "||" est leur priorité.
Juste pour rendre la vie intéressante, "et" et "ou" ont la même priorité, alors que "&&" a une priorité plus élevée que "||".