Salut à vous les intéressés des noeuds au cerveau ! Aujourd’hui pour continuer l’apprentissage du Swift et des complexités qu’il implique, nous allons nous pencher un peu plus en détail sur ce qu’il est possible de faire avec des conditions. Qui n’aime pas lorsqu’il y a des conditions complexes (et parfois inutiles, n’est-ce pas demande de crédit immobilier !?) à remplir et à vérifier pour obtenir quelque chose ? Alors c’est votre jour de chance, nous allons de ce pas nous attaquer à un niveau plus complexe mais surtout plus intéressant de la façon de vérifier des conditions en Swift pour que vous deveniez vous-aussi un véritable créateur de documents Cerfa !
De l’espace gagné
Voyons d’abord un moyen de gagner de l’espace parce que même s’il est infini il n’est est pas moins cher à la location, surtout en meublé ! En effet écrire une condition complète comme on l’a déjà appris ça prend minimum 3 lignes et si on a un “sinon” eh bien on passe à 6 lignes minimum et ça peut vite prendre de la place. Fort heureusement, des parisiens astucieux on trouvé un moyen de regrouper une condition fonctionnelle et sa contre-partie en une seule ligne pour plus de confort et de rentabilité. Voyons un peu comment cela fonctionne :
Pratique non ? On écrit simplement la condition telle qu’elle figurerai dans le if suivie d’un point d’interrogation, puis les code à exécuter si la condition est vraie ou fausse, eux-mêmes séparés par deux points. Voyons en vrai Swift ce que ça donne :
1 2 3 4 5 6 7 8 9 10 11 12 | let heure = 8 if heure < 12 { matin() } else { apresMidi() } // Equivalent heure < 12 ? matin() : apresMidi() |
Il est même possible de directement stocker de le résultat de l’appel, cela permet notamment de créer des constantes (qui sont plus stables et moins gourmands en RAM) plutôt que des variables :
1 2 3 4 5 6 7 8 9 10 | let heure = 8 var matin = "non" if heure < 12 { matin = "oui" } // Equivalent let matin = heure < 12 ? "oui" : "non" |
Notons d’ailleurs que le code heure < 12 est directement interprété par le compilateur comme étant une fonction retournant un booléen, par conséquent si la variable matin est elle-même un booléen, il est possible de lui attribuer directement le résultat de l’exécution de cette condition :
1 2 3 | let heure = 8 let matin: Bool = heure < 12 // matin = true |
Les combinaisons de conditions
Imaginons maintenant que nous souhaitions en savoir un peu plus sur l’heure qu’il est, par exemple savoir si c’est l’heure du gouter, on prendra comme référence 16 et 17 comme heures du gouter convenables. On va devoir vérifier si notre nombre est strictement égale à 16 ou strictement égal à 17. On pourrait imaginer le faire comme ça :
1 2 3 4 5 6 7 8 9 | let heure = 8 var estCeQueCestLheureDuGouter = false if heure == 16 { estCeQueCestLheureDuGouter = true } else if heure == 17 { estCeQueCestLheureDuGouter = true } |
Mais tout ceci semble assez redondant et on s’imagine aisément la longueur du code si il fallait vérifier quelque chose d’un peu plus complexe que l’heure du gouter, disons par exemple savoir si le gouter est possible en fonction de l’âge, de l’heure, et de si il reste du chocolat chaud ou pas ! Pour éviter de trop se casser la tête, nous allons pouvoir faire appel aux opérateurs logiques que sont OU et ET.
- OU que l'on note || (⌥+⇧+Lsur un clavier Mac AZERTY) permet de vérifier si l'une ou l'autre ou les deux conditions d'entrée sont vraies. En clair si au moins l'une des entrées est vraie, alors le résultat sera vrai
- ET que l'on note && permet de vérifier si les deux conditions d'entrée sont vraies. Si l'une des deux ou les deux sont fausses le résultat sera faux
Voici leurs tables logiques qui permettent de représenter le résultat de ces opérateurs en fonction des entrées qui leur sont fournies (en booléen) :
Entrée 1 && Entrée 2 = Sortie ( ET ) |
||
|---|---|---|
| Entrée 1 | Entrée 2 | Sortie |
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |
Entrée 1 || Entrée 2 = Sortie ( OU ) |
||
|---|---|---|
| Entrée 1 | Entrée 2 | Sortie |
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |
Voyons un peu comment cela s’applique à notre exemple de gouter avec nos nouveaux opérateurs :
1 2 3 4 5 6 7 8 9 10 11 12 | let heure = 8 var estCeQueCestLheureDuGouter = false // En utilisant un OU pour vérifier que l'une des deux conditions soit vraie if heure == 16 || heure == 17 { estCeQueCestLheureDuGouter = true } // En utilisant un ET pour vérifier que les deux conditions soient vraies if heure > 15 && heure < 18 { estCeQueCestLheureDuGouter = true } |
Voilà ! On a même deux façons de vérifier que ce soit bien l’heure : il est 16 heures OU il est 17 heures ou bien il est plus de 15 heures ET moins de 18 heures.
Il est d’ailleurs possible d’utiliser les combinaisons dans des conditions condensées comme on a vu plus haut :
1 2 | estCeQueCestLheureDuGouter = (heure == 16 || heure == 17) estCeQueCestLheureDuGouter = (heure >= 16 && heure <= 17) |
Dans ce cas il est recommandé de mettre la condition entre parenthèses pour plus de lisibilité. Les parenthèses ici ont la même utilisation qu’en mathématiques, cela nous permet donc de prioriser et séparer des combinaisons de conditions à notre gré. On peut ainsi combiner des combinaisons à l’infini, attention tout de même à la lisibilité si cela devient trop grand. Voici quelques exemples :
1 2 3 | (true && false) || true // true (true || false) && false // false (true || false) && (true && false) // false |
Notons que si nous testons la déclaration de variables non-nulles, il ne sera pas possible d’utiliser ET ou OU pour les combiner avec d’autres conditions, on utilisera alors une simple virgule qui agit comme un ET lors du test :
1 2 3 | if (true || false), let variable = variableOptionnelle { // si vrai OU faux ET vrariable n'est pas nul } |
Allez pour s’assurer que vous avez bien compris, je vous demande de trouver si cette combinaison va retourner true ou false (et de tête s’il vous plait !):
true && ( true ) && (( false ) || false) && (true && ( true ))
true && ( false ) && ( true )
true && false
// False !
Simple non ?
Non
Et pourtant si ! Il existe bien un dernier opérateur que nous n’avons pas encore vu, et il s’agit de NON. Celui-ci est assez simple dans son fonctionnement, en effet il inverse purement et simplement le résultat d’une condition. Si elle est fausse elle deviendra vraie, si elle est vraie elle deviendra fausse. Pour ce faire, il nous suffit d’ajouter un point d’exclamation juste avant la condition à vérifier afin de l’inverser. On notera ainsi :
1 2 | !true // false !(true && false) // true |
Notons que le point d’exclamation doit être positionné avant la valeur à inverser sans espace entre eux pour qu’il soit considéré comme un opérateur NON. Voici sa table logique qui est en fait assez simple :
!Entrée = Sortie ( NON ) |
|
|---|---|
| Entrée | Sortie |
| true | false |
| false | true |
Et voilà ! Vous êtes à présent parés à tester tout ce qui peut se présenter à vous et combiner tout ça pour un maximum d’efficacité et de lisibilité dans votre code. Rappelez-vous que le plus important est en premier d’éviter de réécrire du code qui fait la même chose à plusieurs endroits (notamment dans des conditions) et ensuite de pouvoir re-lire et comprendre votre code sans avoir à le déchiffrer pendant une heure. Vous aurez besoin de pratique pour vraiment maitriser les combinaisons mais vous possédez maintenant toutes les connaissances pour y arriver ! Je vous dis à bientôt pour de nouvelles aventures 🙂