#4 Fonctions et contrôle de flux

Définir des fonctions

En Rust, les fonctions sont déclarées avec le mot-clé fn. Par convention, les noms de fonctions utilisent le snake_case (minuscules avec underscores).

fn dire_bonjour() {
    println!("Bonjour depuis ma fonction !");
}

fn main() {
    dire_bonjour();
}

L'ordre de déclaration n'a pas d'importance en Rust : vous pouvez appeler une fonction définie plus bas dans le fichier.

Paramètres et types de retour

Les paramètres doivent toujours avoir un type annoté. Pour retourner une valeur, on utilise la flèche -> suivie du type de retour.

fn additionner(a: i32, b: i32) -> i32 {
    a + b // Pas de ; → c'est la valeur retournée
}

fn main() {
    let resultat = additionner(3, 7);
    println!("La somme de 3 + 7 = {resultat}");
}

Point important : en Rust, la dernière expression d'une fonction (sans point-virgule) est automatiquement retournée. Vous pouvez aussi utiliser return explicitement, mais c'est rarement nécessaire.

if / else

Les conditions en Rust n'utilisent pas de parenthèses autour de la condition (contrairement au C ou Java). Les accolades sont obligatoires.

let nombre = 5;

if nombre > 0 {
    println!("{nombre} est positif");
} else if nombre < 0 {
    println!("{nombre} est négatif");
} else {
    println!("{nombre} est zéro");
}

En Rust, if est une expression : il retourne une valeur. On peut l'utiliser directement dans un let :

let x = 5;
let label = if x > 0 { "positif" } else { "négatif ou zéro" };
println!("{label}");

Les boucles

Rust propose trois types de boucles : loop, while et for.

let mut compteur = 0;

loop {
    compteur += 1;
    println!("Compteur : {compteur}");
    if compteur == 3 {
        break; // Sort de la boucle
    }
}

let mut n = 3;

while n > 0 {
    println!("{n} !");
    n -= 1;
}
println!("Décollage !");

// Parcourir un intervalle
for i in 1..=5 {
    println!("{i}");
}

// Parcourir un tableau
let fruits = ["pomme", "banane", "cerise"];
for fruit in fruits {
    println!("{fruit}");
}

L'expression match

match est l'équivalent du switch dans d'autres langages, mais beaucoup plus puissant. Le compilateur vérifie que tous les cas sont couverts.

let couleur = "rouge";

let code_hex = match couleur {
    "rouge" => "#FF0000",
    "vert"  => "#00FF00",
    "bleu"  => "#0000FF",
    _       => "#000000", // _ = tous les autres cas
};

println!("Couleur : {couleur} -> {code_hex}");

Le _ est un joker qui capture tous les cas non listés. Sans lui, le compilateur refuserait de compiler si un cas manque.

À vous de jouer

Essayez les commandes ci-dessous pour exécuter les exemples :