Structures de contrôle

# Les structures de contrôle

---
## Les branchements conditionnels

```rust [3-5|6-8|9-11|]
fn main() {
    let x = 15; 
    if x < 10 {
        println!("{} est plus petit que 10.", x);
    } 
    else if x >= 10 && x < 20 {
        println!("{x} est plus grand ou égal à 10 et plus petit que 20.");
    } 
    else {
        println!("{x} est plus grand ou égal à 20.");
    }
}
```

---
## C'est des **expressions**

```rust [2|4-10|4,6,9,10|]
fn main() {
    let x = -1;
    let sign = 
        if x > 0 {
            1 // pas de ;
        } else if x < 0 {
            -1 // pas de ;
        } else {
            0 // pas de ;
        }; // attention au ;
    println!("Le signe de x est {sign}.");
}
```

---
## Similaire au `?` en C

```C 
int sign = (x > 0) ? 1 : ((x < 0) ? -1 : 0);
```

---
## La boucle infinie: `loop`

```rust ignore []
fn main() {
    loop {
        println!("En boucle!");
    }
}
```

---
## Sortie avec `break`

- `break` permet de sortir du bloc itératif courant.
- On peut aussi retourner une valeur avec `break <valeur>`.
- La valeur retournée par `break` est celle de l'expression `loop`.

```rust [3,10|8|]
fn main() {
    let mut i = 0;
    let j = loop {
        println!("{}, en boucle!", i);
        i += 1;
        if i == 10 {
            println!("Fin de la boucle!");
            break i; // i est optionnel
        }
    }; // attention au ;
}
```

---
## La boucle `while`

```rust [3,6|]
fn main() {
    let mut i = 0;
    while i != 10 {
        println!("{}-ème boucle!", i);
        i += 1;
    }
    println!("Fin de la boucle!");
}
```

---
## La boucle `for` et `continue`

```rust [2,7|3-5|]
fn main() {
    for i in 0..10 {
        if i % 2 == 0 {
           continue;
        }
        println!("{}-ème boucle!", i);
    }
    println!("Fin de la boucle!");
}
```  
- `0..10` de `0` à `10` non inclu.
- `0..=10` de `0` à `10` inclu.
- `0..10` est une `Range` (une collection).

---
## Résumé

- `if <condition> { ... } else { ... }` pour les branchements conditionnels.
- `loop { ... }` pour une boucle infinie.
- `while <condition> { ... }` pour une boucle avec une condition.
- `for <var> in <collection> { ... }` pour une boucle sur une collection.
- `break` pour sortir d'une boucle.
- `continue` pour passer à l'itération suivante d'une boucle.
- Les structures de contrôle sont des **expressions**.

---
## Rustlings

- Faires les rusltings sur les structures de contrôle

---
## Exercice

- Écrire un programme qui joue au jeu FizzBuzz.
- Pour les nombres de 1 à 100:
  - Si le nombre est divisible par 3, afficher "Fizz".
  - Si le nombre est divisible par 5, afficher "Buzz".
  - Si le nombre est divisible par 3 et 5, afficher "FizzBuzz".
  - Sinon, afficher le nombre.