0Pricing
Learn Rust Coding · Leçon

Fonctions et flux de contrôle

Apprenez à définir des fonctions et à utiliser les expressions `if`/`else`, `loop`, `while` et `for` pour contrôler le déroulement de l’exécution d’un programme.

Fonctions et flux de contrôle est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Que sont les fonctions ?

Les fonctions sont des blocs de code nommés qui réalisent une tâche précise. Elles sont essentielles pour organiser votre code et le rendre réutilisable.

  • Réutilisation du code : écrivez une logique une seule fois et utilisez-la plusieurs fois.
  • Modularité : décomposez les problèmes complexes en parties plus petites et gérables.
  • Lisibilité : donnez des noms pertinents aux blocs de code afin de faciliter leur compréhension.

Votre première fonction Rust

En Rust, vous définissez une fonction à l’aide du mot-clé fn. La fonction main est le point d’entrée de chaque programme Rust.

Voici comment déclarer et appeler une fonction simple :

fn say_hello() {
    println!("Hello from a function!");
}

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Fonctions avec paramètres

Les fonctions peuvent accepter des valeurs d’entrée appelées paramètres. Ceux-ci permettent à votre fonction de traiter des données différentes à chaque appel.

Les paramètres sont définis par un nom et un type, séparés par deux-points.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Fonctions avec valeurs de retour

Les fonctions peuvent également renvoyer une valeur à l’appelant. Vous indiquez le type de retour après une flèche (->).

La dernière expression du corps de la fonction est renvoyée implicitement. Aucun point-virgule n’est nécessaire pour l’expression de retour !

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Prendre des décisions : `if`/`else`

L’expression if permet à votre programme d’exécuter différents blocs de code en fonction d’une condition. Les conditions doivent toujours être de type bool (vrai/faux).

  • Utilisez if pour la première condition.
  • Utilisez else if pour les conditions supplémentaires.
  • Utilisez else comme solution de repli si aucune autre condition n’est remplie.

Le if de Rust est une expression, ce qui signifie qu’il peut renvoyer une valeur !

Les expressions if-else en action

Voici comment utiliser if et else pour attribuer une valeur en fonction d’une condition. Remarquez qu’ils se comportent comme un opérateur ternaire dans d’autres langages.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Répéter du code : `loop`

Le mot-clé loop crée une boucle infinie. C’est utile lorsque vous devez répéter une action jusqu’à ce que vous décidiez explicitement de l’arrêter.

Utilisez break pour quitter la boucle. Vous pouvez même renvoyer une valeur depuis une expression loop à l’aide de break.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Répétition conditionnelle : `while`

La boucle while exécute un bloc de code tant qu’une condition donnée reste vraie. Elle est idéale lorsque vous ne savez pas exactement combien de fois vous devez effectuer la boucle.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Itérer avec les boucles `for`

La boucle for sert à parcourir une collection d’éléments ou une plage de nombres. Il s’agit de la construction de boucle la plus courante en Rust, ce qui rend votre code sûr et concis.

  • Elle est souvent utilisée avec des plages (par exemple, 1..4 pour 1, 2, 3 ou 1..=4 pour 1, 2, 3, 4).
  • Elle fonctionne avec tout type qui implémente le trait Iterator.
fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Défi sur le flux de contrôle

Considérez le code Rust suivant. Quelle sera la valeur finale de result ?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Récapitulatif des fonctions et du flux de contrôle

Vous maîtrisez désormais les éléments fondamentaux des programmes dynamiques !

  • Fonctions : organisez et réutilisez le code à l’aide de fn, de paramètres et de valeurs de retour.
  • if/else : prenez des décisions et exécutez du code sous condition. N’oubliez pas qu’il s’agit d’une expression !
  • loop : créez des boucles infinies, quittez-les avec break et renvoyez des valeurs.
  • while : effectuez une boucle tant qu’une condition est vraie.
  • for : parcourez des collections et des plages en toute sécurité.

Ces outils sont essentiels pour écrire des programmes Rust structurés et efficaces !

Questions Fréquemment Posées

La leçon « Fonctions et flux de contrôle » est-elle gratuite ?

Oui — le texte complet de « Fonctions et flux de contrôle » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions et flux de contrôle » ?

Apprenez à définir des fonctions et à utiliser les expressions `if`/`else`, `loop`, `while` et `for` pour contrôler le déroulement de l’exécution d’un programme. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Fonctions et flux de contrôle » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Variables, mutabilité et masquage
  2. Types de données primitifs et opérateurs
  3. Fonctions et flux de contrôle
← Retour à Learn Rust Coding