---
title: Cours de programmation séquentielle
subtitle: Structures de contrôle
author: Orestis Malaspinas
<!-- date: 25 avril 2018 -->
sansfont: Sans Serif
---

# Les expressions `if`{.rust}

## Le `if`{.rust} simple

- Permet d'effectuer un branchement dans le code quand une condition est remplie:

    Soit une condition donnée, si cette condition est remplie, on exécute un **bloc** de code.
    On ne l'exécute pas si la condition n'est pas remplie.

- La syntaxe est:

    ~~~{.lang-rust}
    if condition {
        // certaines instructions
    }
    ~~~

- Exemple:

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 5; 

    if x < 10 {
        println!("{} est plus petit que 10.", x);
    } 
}
    </code></pre>  

## Le `if ... else`{.rust} 

- Permet d'effectuer un branchement dans le code quand une condition est remplie ou si elle ne l'est pas:

    Soit une condition donnée, si cette condition est remplie, on exécute un **bloc** de code, 
    si elle ne l'est pas on exécute un autre **bloc**.

- La syntaxe est:

    ~~~{.lang-rust}
    if condition {
        // certaines instructions
    } else {
        // d'autres instructions
    }
    ~~~

- Exemple:

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 5; 

    if x < 10 {
        println!("{} est plus petit que 10.", x);
    } else {
        println!("{} est plus grand ou égal à 10.", x);
    }
}
    </code></pre>  


## Le `if ... else if ... else`{.rust} 

- Permet d'effectuer un branchement dans le code quand plusieurs conditions sont remplies... ou pas:

- La syntaxe est:

    ~~~{.lang-rust}
    if condition1 {
        // certaines instructions
    } else if condition2 {
        // d'autres instructions
    } else {
        // encore d'autres instructions
    }
    ~~~

- Exemple:

<pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 15; 

    if x < 10 {
        println!("{} est plus petit que 10.", x);
    } else if x >= 10 && x < 20 {
        println!("{} est plus grand ou égal à 10 et plus petit que 20.", x);
    } else {
        println!("{} est plus grand ou égal à 20.", x);
    }
}
</code></pre>  

# Les boucles

## La boucle `loop`{.rust}

- Une boucle inifie:

    ~~~{.lang-rust}
    fn main() {
        loop {
            println!("En boucle!");
        }
    }
    ~~~

- On sort d'une boucle avec `break`{.rust}

<pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let mut i = 0;
    loop {
        println!("{}, en boucle!", i);

        i += 1;
        if i == 10 {
            println!("Fin de la boucle!");

            break;
        }
    }
}
</code></pre>  

## La boucle `while`{.rust}

- Boucle conditionnelle: on remplace `loop, if, et break`{.rust} par `while`{.rust}.

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let mut i = 0;
    while i != 10 {
        println!("{}-ème boucle!", i);
        i += 1;
    }
    println!("Fin de la boucle!");
}
    </code></pre>  

## La boucle `for`{.rust}

- Encore plus concis que `while`{.rust}

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    for i in 0..10 {
        println!("{}-ème boucle!", i);
    }
    println!("Fin de la boucle!");
}
    </code></pre>  

- La syntaxe permet d'itérer sur bien plus que juste des entiers, mais on verra ça plus tard.

    ~~~{.lang-rust}
    for i in collection {
        // instructions
    }
    ~~~

