3

Commencer avec swift : les boucles

Posté le par Onoulade
Dernière modification le
Cet article n'a pas été mis à jour depuis plus d'un an, il est possible que certaines informations ne soient plus à jour. Si vous rencontrez des erreurs ou des différences en le suivant, n'hésitez pas à commenter pour me le signaler.

On va s’intéresser maintenant à un outil indispensable dans la programmation : les boucles. Elles ne font que répéter des actions un certain nombre de fois mais sont une des briques indispensables à la construction d’un programme. Le tout est de faire en sorte qu’elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours. Le tout est de faire en sorte qu'elles ne se répètent pas pour toujours.

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, Banane
  • fruits[...2] : éléments du tableau compris entre le début et l’index 2 inclus : Orange, Pomme, Banane
  • fruits[..<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 !

Suite du tutoriel Commencer avec Swift

Les fonctions

Laisser un commentaire

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