Cette documentation est encore en cours de rédaction chez Apple et des corrections peuvent être apportées au cours des semaines à venir.

Les opérateurs logiques modifient ou combinent deux valeurs booléennes logiques true et false. Swift supporte les trois opérateurs logiques standards que l’on retrouve dans les langages basés sur le C :

  • L'opérateur logique NOT (!a)
  • L'opérateur logique AND (a && b)
  • L'opérateur logique OR (a || b)

Opérateur logique NOT

L’opérateur logique NOT (!a) inverse la valeur d’un booléen, true devient false et false devient true.

L’opérateur logique NOT est toujours un préfixe, il apparait immédiatement avant la valeur sur laquelle il opère, sans ajouter d’espace. Il peut être lu de la façon suivante : “n’est pas a, comme vous pouvez le voir dans l’exemple ci-dessous :

1 let entreeAutorise = false
2 if !entreeAutorise {
3     println("ACCÈS REFUSÉ")
4 }
5 // Affiche "ACCÈS REFUSÉ"

La phrase if !entreeAutorise peut être lue “Si l’entrée n’est pas autorisé”. La ligne suivante est exécutée uniquement si l’entrée non autorisée est true. Dans cet exemple choisissez bien le nom de vos variables et de vos constantes booléennes, pour obtenir un code plus lisible et compréhensible, pour prévenir les doubles négatives ou les confusions.

Opérateur logique AND

L’opérateur logique AND (a && b) crée une expression logique ou les deux valeurs doivent être true pour que l’ensemble de l’expression soit aussi true. Si l’une des deux valeurs est false, l’expression devient aussi false. En réalité, si la première valeur est false, la seconde valeur n’est même pas évaluée, car il est impossible qu’au final l’expression puisse être true.

Cet exemple initialise deux constantes booléennes et n’autorise l’accès que si elles sont toutes les deux à true :

1 let codePorte = true
2 let scanRetinien = false
3 if codePorte && scanRetinien {
4     println("Welcome !")
5 } else {
6     println("ACCÈS REFUSÉ")
7 }// Affiche "ACCÈS REFUSÉ"

Opérateur logique OR

L’opérateur logique OR (a || b) se place toujours entre deux valeurs et correspond à barres parallèles adjacentes. Ce caractère est facile à trouver sur un clavier Windows, pour Mac il faudra presser les touches ALT + SHIFT + L.

L’opérateur logique OR permet de créer une expression logique où l’une ou toutes les valeurs de l’expression valent true. Si c’est le cas alors l’expression complète vaut elle aussi true.

Comme pour l’opérateur logique AND vu ci-dessus, l’opérateur logique OR n’analysera pas les autres valeurs de l’expression si la première est déjà à true. Il est évident que du coup toute l’expression sera forcement à true.

Dans l’exemple ci-dessous, le premier booléen est false mais la seconde valeur est true. L’expression complète est évaluée à true et l’accès est autorisé :

1 let clePorte = false
2 let reinitialisationCode = true
3 if clePorte || reinitialisationCode {
4     println("Welcome !")
5 } else {
6     println("ACCÈS REFUSÉ")
7 }// Affiche "Welcome !"

Combiner les opérateurs logiques

Vous pouvez combiner de nombreux opérateurs logiques pour créer de plus longues expressions à faire vérifier par votre code :

1 if codePorte && scanRetinien || clePorte || reinitialisationCode {
2     println("Welcome !")
3 } else {
4     println("ACCÈS REFUSÉ")
5 }// Affiche "Welcome !"

Cet exemple utilise de nombreux opérateurs logiques comme && et || pour créer une expression plus longue. Cependant, les opérateurs && et || n’opèrent chacun uniquement que sur deux valeurs, du coup il s’agit ici en fait de trois plus petites expressions collées les unes aux autres.

L’expression peut être lue : “Si j’ai entré correctement le code de la porte et passé avec succès le scan rétinien; ou si j’ai la clé de la porte; ou je sais réinitialiser le code, alors je suis autorisé à entrer”.

En se basant sur les valeurs des constantes que nous avons initié dans nos exemples, la première expression est false. Cependant je sais réinitialiser le code d’entrée, du coup l’expression complète est true. La suite de l’expression n’a pas besoin d’être analysée puisqu’elle sera forcement true.

En ajoutant des parenthèses

Si le cours des opérations de vérifications effectuées par les opérateurs logiques ne vous convient pas, vous pouvez ajouter des parenthèses pour séparer les expressions de l’expressions globale comme bon vous semble. Même si vos parenthèses ne modifient pas la façon dont est interprétée l’expression globale, elles peuvent faciliter la lecture de votre code. Dans l’exemple des portes de de leur code d’accès, il peut être utile d’ajouter des parenthèses pour faciliter la compréhension de l’expression globale :

1 if (codePorte && scanRetinien) || clePorte || reinitialisationCode {
2     println("Welcome !")
3 } else {
4     println("ACCÈS REFUSÉ")
5 }// Affiche "Welcome !"

Les parenthèses montrent plus clairement que les deux premières constantes sont considérée comme une expression à part entière de l’expression globale. Le résultat n’est pas affecté pour autant, l’expression est toujours true, néanmoins l’expression globale est beaucoup lisible ainsi.