Conditions et boucles en Swift

Dans cet article, nous allons voir comment gérer les boucles et les conditions en Swift. Ce sont deux éléments fondamentaux de la programmation.

Les conditions permettent de prendre des décisions en fonction de la valeur de certaines variables, tandis que les boucles permettent de répéter des blocs de code plusieurs fois jusqu’à ce qu’une condition soit remplie.

Elles sont essentielles à implémenter correctement car elles permettent de créer des programmes plus efficaces, dynamiques et précis.

Les boucles

Elles permettent la répétition de code de manière lisible et efficace. En effet, il est important de coder de manière propre et les boucles permettent d’éviter les répétitions inutiles.

A l’intérieur d’une boucle, je peux trouver les traitements suivants :

• continue : demande au code de continuer dans la boucle en vérifiant les autres conditions.
• break : arrête l’exécution de la boucle.

🔄 Boucles for ... in

On peut utiliser les boucles pour itérer à travers n’importe quelle collection (tableaux, dictionnaires, sets, etc.), ainsi que des plages données ou des chaînes de caractères.

Par exemple, on peut donner à la boucle une plage de répétitions définie. Ici, la boucle se répétera 3 fois car on lui donne le rang de 0 à 2 :

for i in 0...2 {
    print("L'an 200\(i).")
}
// Affiche :
// L'an 2000.
// L'an 2001.
// L'an 2002.

On peut lire cette boucle de cette manière : « Affiche la phrase ‘L’an 200… + i’ avec la variable i qui est l’index de cette boucle ».

A travers un tableau :

let names = ["Anna", "Alex", "Brian", "Jack"]

print("Hello, \(names[0])!")
print("Hello, \(names[1])!")
print("Hello, \(names[2])!")
print("Hello, \(names[3])!")

C’est comme ça qu’on écrirait sans une boucle. Avec la boucle le code est simplifié et beaucoup plus lisible :

for name in names {
    print("Hello, \(name)!")
}

A travers un dictionnaire :

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
    print("\(animalName)s have \(legCount) legs")
}
// cats have 4 legs
// ants have 6 legs
// spiders have 8 legs

Si je n’ai pas besoin de récupérer une variable à afficher dans la boucle, j’utilise _ :

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
print("\(base) à la puissance \(power) donne \(answer)")
// Affiche "3  à la puissance 10 donne 59049"

L’exemple ci-dessus calcule la valeur d’un nombre à la puissance d’un autre (dans ce cas, 3 à la puissance 10).

Autres exemples de boucles for ... in en Swift :

let minutes = 60
for tickMark in 0..<minutes { // intervalle de 0 à 60 minutes
    // render the tick mark each minute (60 times)
}

let hours = 12
let hourInterval = 3
for tickMark in stride(from: 3, through: hours, by: hourInterval) {
    // render the tick mark every 3 hours (3, 6, 9, 12)
}

🔄 Boucles while

Une boucle while exécute une série d’instructions jusqu’à ce que la condition devienne fausse. On l’utilise quand on ne sait pas de combien de répétitions nous allons avoir besoin.

On peut les utiliser de 2 manières :

• while : la condition est vérifiée au début de chaque passage dans la boucle
• repeat-while : la condition est vérifiée à la fin de chaque passage

var count = 0
var rollDice = 0

while count < 20 {
    rollDice = Int.random(in: 1...6) // je génère un nombre aléatoire entre 1 et 6
    print("Le lancer de dé est de \(rollDice)")
    count += rollDice // j'ajoute le résultat à mon total de points
    print("Le total est de \(count)")
}

//Syntaxe de la boucle repeat-while
repeat {
    rollDice = Int.random(in: 1...6)
    print("Le lancer de dé est de \(rollDice)")
    count += rollDice
    print("Le total est de \(count)")
} while count < 20

Les conditions

Il est souvent utile d’exécuter différents éléments de code en fonction de certaines conditions. On pourra utiliser deux façons différentes de poser nos conditions.

A la fin de chaque condition, on peut ajouter une instruction qui modifiera l’ordre de traitement de la condition :

• break : arrête l’exécution de la boucle.
• fallthrough : le code doit continuer à s’exécuter vers le cas suivant sans sortir du bloc switch.

⤵️ If / else

La paire if et else est la plus couramment utilisée. Elle se traduit par « si la condition est vraie, alors exécute le code, sinon, exécute ce code là ».

var age = 22
if age >= 21 {
    print("Tu es majeur en Amérique 🥂 !")
} else if age >= 18 {
    print("Tu es majeur en France 🍻 !")
} else {
    print("Tu es mineur 🧃 !")
}
// Tu es majeur en Amérique 🥂 !

Comme tu peux le voir, l’ordre des conditions est important. Si on avait écrit >= 18 avant >= 21, nous ne serions jamais entrés dans la condition age >= 21.

⤵️ Switch

La condition switch permet d’éviter le if après un if après un if après un … T’as compris (je ne suis pas en boucle infinie pourtant 😝) ! Je saute directement à la condition qui m’intéresse.

On pourrait également utiliser la déclaration switch dans le même exemple que précédemment :

switch age {
case 0..<18 :
    print("Tu es mineur 🧃 !")
case 18..<21 :
    print("Tu es majeur en France 🍻 !")
default :
    print("Tu es majeur en Amérique 🥂 !")
}

On parle ici d’intervalles mais les conditions de chaînes de caractères strictement égales sont également applicables (comme la comparaison de tableaux, etc).

var someCharacter = "a"
switch someCharacter {
    case "a", "A":
        print("La lettre est A")
        fallthrough
    case "b", "B":
        print("La lettre est B")
    case "c", "C":
        print("La lettre est C")
    default:
        print("La lettre n'est ni A, ni B, ni C")
}

Les tuples & la clause where

Les tuples sont utilisés pour tester plusieurs valeurs dans la même instruction. On peut utiliser _ pour correspondre n’importe quelle valeur.

L’exemple ci-dessus prend un point (x,y) (de type (Int, Int)) et le place sur un graphique :

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) is at the origin")
case (_, 0):
    print("\(somePoint) is on the x-axis")
case (0, _):
    print("\(somePoint) is on the y-axis")
case (-2...2, -2...2):
    print("\(somePoint) is inside the box")
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
default:
    print("\(somePoint) is outside of the box")
}
// Affiche "(1, 1) is inside the box"

Defer

Pour différer le code écrit dans cette accolade :

var score = 1
if score < 10 {
    defer {
        print(score)
    }
    score += 5
}
// Affiche "6"

---

Et voilà, tu sais tout sur les boucles et les conditions en Swift ! Si un peu de documentation Apple officielle t’intéresse, je t’invite à suivre ce lien.

Après les collections et les énumérations, je te retrouve bientôt pour te parler des fonctions et closures en Swift.

Dis nous en commentaire si tu souhaites un article sur un sujet en Swift !