0

Commencer avec swift : les conditions

Salut salut ! Aujourd’hui on va découvrir la partie logique de la programmation : les conditions. Pour tous ceux qui ont aimé le dernier article qui traitait des opérateurs arithmétiques vous allez être servi parce que l’on va aller bien plus en profondeur dans les mathématiques abstraites ( chouette ! ). Alors, qu’est ce qu’on attends ?

Bon j’en rajoute un peu, ok, on va parler surtout de logique et de comparaison. Pour celles et ceux qui ne seraient pas familier de la logique mathématique, nous n’en traiterons pas ici et il n’est pas nécessaire de la connaitre pour bien comprendre la logique informatique. Néanmoins les deux disciplines étant très proches (et même basées l’une sur l’autre), certains d’entre vous auront peut-être le désir d’approfondir, je vous mets donc ici un lien vers un très bon cours de l’incontournable OpenClassRooms !

n ∈ ℕnp=1(2p−1)=n2
Mince, justement j’adore ça !

Les opérateurs de comparaison

On vient tout juste de sortir des opérateurs que nous voilà de nouveau plongé dedans. Les opérateurs de comparaison sont des opérateurs qui ne vont pas calculer deux variables mais les comparer. Comme pour les opérateurs classiques, ils ne peuvent comparer que deux variables de même type, et vont retourner un type de variable dont nous avons seulement parlé : les Boolean.

Un boolean est une variable qui contient vrai ou faux comme valeur. Un opérateur de comparaison va retourner “vrai” si la comparaison est vrai ou “faux” si elle ne l’est pas. Essayons dans un playground :

1
2
3
4
5
let un = 1
let trois = 3

un == trois // retourne "false"
un < trois // retourne "true"

Ici on compare un et trois pour savoir s’ils sont égaux (==) ce qui n’est pas exact, donc la comparaison est fausse. Ensuite cherche a savoir si un est plus petit que (<) trois ce qui est vrai. Voici les comparateurs :

  • == : est strictement égal à
  • != : est différent de
  • < : est inférieur à
  • > : est supérieur à
  • <= : est inférieur ou égal à
  • >= est supérieur ou égal à

On peut grâce à eux comparer des variables contenant des nombres mais aussi des chaines de caractères, ou des caractères simples.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let a:Character = "a"
let b:Character = "b"

a == b // false
a <= b // true
a < b // true

let aa:String = "aa"
let ab:String = "ab"
let ba:String = "ba"
let AA:String = "AA"

aa < ab // true
ba < ab // false
AA < aa // true
AA < ba // true

Ils sont considérés comme des nombres dans ce cas (a = 1, b = 2, etc…) et si plusieurs caractères sont présent, swift va agir comme s’il s’agissait de nombres à virgules. Par exemple aa vaudrait 1.1 , ab vaudrait 1.2 , ba vaudrait 2.1 , etc… Les majuscules sont considérées plus petites que les minuscules (allez savoir pourquoi, en tout cas si vous trouvez ca m’intéresse !). Il reste néanmoins très rare de comparer des chaines de caractères autrement qu’avec == ou != .

Avec des si…

Parfait ! Maintenant que l’on sait comparer des variables, on va pouvoir exécuter du code en fonction du résultat de ces comparaison. On va définir une condition, c’est a dire que l’on va pouvoir écrire un code qui ne s’exécutera que si la condition testée est vrai (et seulement dans ce cas.

On peut tester la vérité (true) d’une comparaison avec le mot-clé if (littéralement “si”) suivi de la comparaison à tester. Puis le code à exécuter est entouré par des accolades { } qui peuvent se faire simplement sur un clavier de mac avec la touche ⌥ et les parenthèses (alt + parenthèse gauche ou droite). Voici un test simple à réaliser chez soi.

1
2
3
4
5
6
7
8
9
10
var energieActuelle = 125
let energieRequise = 100

if energieActuelle >= energieRequise {
print("Kamé Hamé Ha")
}

if energieActuelle < energieRequise {
print("Pas assez d'énergie")
}

Ici, rien de plus simple, si on a assez d’énergie alors on exécute le code print("Kamé Hamé Ha"). Ce code est un appel de la fonction print qui permet d’afficher du texte dans la console. Il est possible d’ouvrir la console en cliquant sur la flèche vers le haut à coté du bouton play du playground situé en dessous de la fenêtre de code.

Sinon !

Le code que l’on a écrit et exécuté, même s’il fonctionne n’est pas tout à fait correct. Ici nous testons deux conditions contraires à la suite. Sur un code plus complexe et avec des conditions bien souvent plus nombreuses, il est préférable de ne tester que ce qui est nécessaire. Il existe pour cela un mot-clé qui signifie “sinon” : else. Il s’utilise à la suite d’une condition if et s’exécutera si cette dernière ne l’est pas.

1
2
3
4
5
6
7
8
9
10
var energieActuelle = 125
let energieRequise = 100

if energieActuelle >= energieRequise {
print("Kamé Hamé Ha")
}

else {
print("Pas assez d'énergie")
}

Le code est ainsi plus facilement lisible et modifiable. En effet il est possible de modifier l’opérateur de la condition if pour qu’automatiquement le else accepte tous les autres cas. Simple. Efficace.

else if

Il est possible de combiner les deux mots-clés else et if pour calculer littéralement “sinon, si…”. Le code contenu dans les accolades s’exécutera si aucune condition écrite au préalable n’est remplie et que celle-ci l’est.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var energieActuelle = 85
let energieRequise = 100

let difference = energieRequise - energieActuelle // 15

if energieActuelle >= energieRequise  {
    // Si on a assez d'énergie
    print("Kamé Hamé Ha")
}
else if difference < 20 {
    // Sinon, si il nous manque moins de 20 points d'énergie
    print("Vous avez presque assez d'énergie")
}
else {
    // Sinon
    print("Pas assez d'énergie")
}

Ici, on calcule une variable difference qui contient l’écart entre notre énergie actuelle et l’énergie requise pour un Kamé Hamé Ha. Si on a pas assez d’énergie, mais qu’il nous en manque moins de 20 alors le script retournera : “Vous avez presque assez d’énergie”. Il est possible de mettre une multitude de else if les uns à la suite des autres tous testant différentes variables, mais attention à ne pas s’emmêler les pinceaux !

Les tests de déclaration

Il est possible de tester si une déclaration de variable s’effectue correctement simplement en déclarant cette variable dans le if. Si la déclaration a réussi, alors la variable sera accessible dans toute la fonction. Par exemple, on peut tester si la transformation d’une chaine de caractère en nombre a fonctionné :

1
2
3
4
let nb = "18"       // "18"
if let nombre = Int(nb) {
    print(nombre)   // 18
}

La constante nombre est donc de type Int et non de type String comme la constante nb. Elle n’est en revanche pas accessible en dehors de la condition. Si on souhaite accéder à nombre après la condition, Xcode retournera une erreur comme si la variable n’avait jamais été déclarée.

Le test ne fonctionnera que pour les opérations pouvant retourner un résultat optionnel. On ne va pas s’attarder ici sur les variables optionnelles car nous aurons tout le loisir d’y revenir plus tard. Si le test de déclaration n’est pas accepté dans la condition, Xcode retrournera une erreur : "Initializer for conditional binding must have Optional type, not 'Int'". Dans ce cas cela signifie généralement que la déclaration de la variable va toujours fonctionner, ou n’est pas testable de cette façon.

Les switch

Pour éviter de s’emmêler les pinceaux, il est possible de tester plus rapidement différentes valeurs à une variable sans s’encombrer de else if à répétition. On peu pour cela déclarer un switch dont la structure est assez différente des conditions “classiques”.

1
2
3
4
5
6
7
8
9
10
11
12
let character = "a"

switch character {        // Ici la variable à tester
case "a":                 // Si la variable vaut "a"
    print("la lettre A")      // code à exécuter
case "b":                 // Si la variable vaut "b"
    print("la lettre B")      // code à exécuter
case "c":                 // Si la variable vaut "c"
    print("la lettre C")      // code à exécuter
default:                  // Si aucun case n'a été vérifié
    print("inconnu")          // code à exécuter par défaut
}

On déclare donc vous chaque valeur à tester d’une variable des différents case qui agissent comme des else if. On peut en déclarer un nombre illimité qui testerons tous la même variable. On peut tester plusieurs valeurs sur chaque condition en séparant les valeurs à tester par des virgules :

1
2
3
4
5
6
7
8
let character = "a"

switch character {
case "a", "e", "i", "o", "u", "y":
    print("voyelle")
default:
    print("consonne")
}

 

Bien ! On a pas mal avancé sur cette partie mais on va se faire une bonne pause lait + cookie avant de continuer. Il y a encore beaucoup à dire rien que sur les conditions qui sont un bloc vraiment très conséquent et très important, mais nous allons d’abord continuer sur les bases du Swift et nous reviendrons plus tard sur des usages plus avancés. On se retrouve bientôt !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *