Opérateurs logiques, partie 4

Fait partie de la section Fondamentaux du Journey Ruby de Coddy — leçon 20 sur 88.

Lorsque vous combinez plusieurs opérateurs logiques dans une seule expression, Ruby les évalue dans un ordre spécifique basé sur la priorité des opérateurs. Comprendre cet ordre vous aide à écrire des conditions correctes et à éviter des résultats inattendus.

La priorité, de la plus élevée à la plus basse, est : ! (non), puis && (et), puis || (ou). Cela signifie que ! est évalué en premier, suivi de &&, et enfin || :

true || false && false   # true (&& est évalué en premier)
# Équivalent à : true || (false && false)

!false && true           # true (! est évalué en premier)
# Équivalent à : (!false) && true

Vous pouvez utiliser des parenthèses pour passer outre la priorité par défaut et rendre vos intentions claires :

(true || false) && false  # false (les parenthèses forcent || en premier)
true || (false && false)  # true (comportement par défaut)

Même lorsque les parenthèses ne sont pas strictement nécessaires, les ajouter rend souvent les expressions complexes plus faciles à lire. En cas de doute, utilisez des parenthèses pour montrer explicitement comment les conditions doivent être groupées.

Défi

Facile

Les variables suivantes vous sont fournies :

x = true
y = false
z = true
a = false

Évaluez les expressions suivantes et affichez chaque résultat sur une ligne distincte. Faites attention à la priorité des opérateurs : ! est évalué en premier, puis &&, et enfin ||.

x || y && z
!y && z
x && y || z
!a || y && z
x && !y && z
(x || y) && a
x || (y && a)
!(x && y) || z

Chaque sortie doit être soit true soit false.

Aide-mémoire

Ruby évalue les opérateurs logiques dans un ordre spécifique basé sur la priorité des opérateurs :

! (not) - priorité la plus haute
&& (and) - priorité moyenne
|| (or) - priorité la plus basse

Exemples de priorité des opérateurs :

true || false && false   # true (&& est évalué en premier)
# Équivaut à : true || (false && false)

!false && true           # true (! est évalué en premier)
# Équivaut à : (!false) && true

Utilisez des parenthèses pour modifier la priorité par défaut ou améliorer la lisibilité :

(true || false) && false  # false (les parenthèses forcent || en premier)
true || (false && false)  # true (comportement par défaut)

Essayez vous-même

# Les variables sont déjà définies pour vous
x = true
y = false
z = true
a = false

# À FAIRE : Évaluer chaque expression et afficher le résultat sur une ligne distincte
# Rappel sur la priorité des opérateurs : ! en premier, puis &&, puis ||

# 1. x || y && z
puts # votre expression ici

# 2. !y && z
puts # votre expression ici

# 3. x && y || z
puts # votre expression ici

# 4. !a || y && z
puts # votre expression ici

# 5. x && !y && z
puts # votre expression ici

# 6. (x || y) && a
puts # votre expression ici

# 7. x || (y && a)
puts # votre expression ici

# 8. !(x && y) || z
puts # votre expression ici