Boucles for-in
Le moyen le plus simple et le plus rapide pour effectuer une boucle en Swift est via le mot-clé for
qui s’utilise de cette manière
1 2 3 4 5 6 7 8 9 10 11 | for i in 0...5 { print(i) } /* 0 1 2 3 4 5 */ |
i est une variable créée dans la boucle (entre les accolades) qui s’exécutera autant de fois que spécifié après in
. Ici, 0...5
signifie « de 0 à 5 inclus ».
On peut également créer une boucle par rapport aux nombres d’éléments dans un tableau. Il suffit de récupérer ce nombre via la méthode .count
d’un tableau. N’oublions pas que le compte des tableaux commence à 0 et non pas 1 ; si il y a 3 éléments dans le tableau, les index seront 0, 1 et 2, on doit donc corriger le compte avec un -1.
1 2 3 4 5 6 7 8 9 10 11 12 13 | let fruits = ["Orange", "Pomme", "Banane"] let nbElements = fruits.count - 1 // 3 - 1 = 2 for i in 0...nbElements { let text = String(i)+" : "+fruits[i] print(text) } /* 0 : Orange 1 : Pomme 2 : Banane */ |
Mais bien heureusement Swift nous autorise à placer directement le tableau dans la boucle et associera automatiquement chaque valeur de la liste à chaque exécution.
1 2 3 4 5 6 7 8 9 10 11 | let fruits = ["Orange", "Pomme", "Banane"] for fruit in fruits { print(fruit) } /* Orange Pomme Banane */ |
Il existe quelques subtilités et variantes intéressantes de cette même méthode pour personnaliser un peu notre exécution. Par exemple, chaque tableau possède un méthode .enumerated()
qui permet lorsqu’elle est passée dans un boucle d’obtenir un couple de variables, l’une représentante l’index du tableau et l’autre sa valeur :
1 2 3 4 5 6 7 8 9 10 11 | let fruits = ["Orange", "Pomme", "Banane"] for (i, fruit) in fruits.enumerated() { print("Index :", i, "valeur :", fruit) } /* Index : 0 valeur : Orange Index : 1 valeur : Pomme Index : 2 valeur : Banane */ |
Les types Range
Les variables utilisées dans les boucles for en deuxième position sont de type Range qui contient des intervalles. Il existe plusieurs intervals possibles pour différents types de variables ce qui évite les confusions de type -1 sur un tableau par exemple. Pour cet exemple prenons a = 0 et b = 3 :
a...b
: de a à b inclus (0, 1, 2, 3)a..<b
: de a inclus à b non inclus (0, 1, 2)a>..b
: de a non inclus à b inclus (1, 2, 3)
Ces trois déclarations peuvent être utilisées pour des variables de type Int ou Character. Il en existe également des spécifiques pour les tableaux :
fruits[1...]
: éléments du tableau compris entre l’index 1 inclus et la fin du tableau : Pomme, Bananefruits[...2]
: éléments du tableau compris entre le début et l’index 2 inclus : Orange, Pomme, Bananefruits[..<2]
: éléments du tableau compris entre le début et l’index 2 non inclus : Orange, Pomme
Il est possible de déclarer une variable de type Range comme n’importe quelle autre variable en swift. Il est possible de tester si un interval contient une certaine valeur avec la méthode .contains(element)
appartenant à ce type de variable.
1 2 3 4 5 6 7 | let range = 0...100 range.contains(10) // true range.contains(-2) // false let chars = "a"..."z" chars.contains("r") // true chars.contains("A") // false |
Attention à ce que le type de variable soit respecté. Si vous déclarez un interval de type Int, vous ne pourrez pas lui demander si il contient autre chose que des nombres, cela retournera une erreur de compilation.
1 2 | let range = 0...100 range.contains("a") // ERROR : Cannot convert value of type 'Int' to expected argument type 'String' |
Les boucles while()
Il existe un autre type de boucles : while
que l’on peut traduire par « tant que ». Il se déclare de cette façon :
1 2 3 4 | var loop = true while loop == true { // code à exécuter } |
Ce code peut se lire « tant que loop == true, exécuter le code de la boucle ». Cela permet de créer une boucle sans avoir combien d’itérations elle va devoir faire. Attention d’ailleurs car les boucles infinies proviennent de ce type de boucles. Eh oui, car dans cet exemple la variable loop ne va jamais être différente de true, par conséquent la boucle va s’exécuter à l’infinie. Il faut donc prévoir de sortir de la boucle depuis l’intérieur.
On peut s’en servir par exemple dans un jeux en disant « tant que la vie du joueur est supérieure à 0, on exécute le code du jeu ». Si on sors de la boucle, c’est qu’on est mort et le jeu d’arrête.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | var health = 10 var degatEnnemi = 1 while health > 0 { // tant qu'on a de la vie print("Vous vous faites attaquer !") health -= degatEnnemi // l'ennemi nous attaque et nous retire de la vie // Plein d'autres actions... print("Votre vie : " + String(health)) } // On est sorti de la boucle, ça veut dire que l'ennemi nous a tué ! print("vous êtes mort !") |
Il est possible de controller l’exécution d’une boucle très simplement grâce à deux mots-clés :
continue
qui permet de continuer l’exécution de la boucle en terminant son itération actuelle pour reprendre à la prochaine. Ca demande la prochaine exécution de la boucle sans être arrivé au bout du code à exécuter.break
qui permet de quitter totalement la boucle, peu importe son état d’exécution.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | var health = 10 var attaque = 2 var esquive = true var attaqueEnnemi = 1 var vieEnnemi = 15 var combatEnCours = true while combatEnCours == true { print("Vous attaquez l'ennemi !") vieEnnemi -= attaque print("Vie de l'ennemi : " + String(vieEnnemi)) if vieEnnemi <= 0 { break // ou bien combatEnCours = false } print("Vous vous faites attaquer !") if esquive == true { print("Vous esquivez le coup !") esquive = false continue } health -= attaqueEnnemi print("Votre vie : " + String(health)) if health <= 0 { break // ou bien combatEnCours = false } } if health > 0 { print("Vous avez gagné !") } else { print("Vous avez perdu !") } |
Voilà, je vous laisse sur ce code sans autres explications, il faut que vous commenciez a pouvoir lire des codes simples en vous aidant de Swift Playgrounds qui détaille vraiment très bien l’exécution du code ! Désolé pour l’attente qu’il y a eu pour cet article, j’étais en plein test du nouvel Xcode 10, je vous en parlerai très bientôt !