Fonctions et expressions Rust

Introduction

Une fonction donne un nom à une tâche afin qu’un programme puisse l’exécuter chaque fois que nécessaire. Une fonction peut recevoir des données d’entrée par l’intermédiaire de paramètres et renvoyer une valeur calculée.

Dans cet atelier, un projet Cargo préparé contient déjà trois fonctions de conversion ainsi que tous leurs appels. À chaque étape, vous remplacerez une expression fictive. Cela limite la quantité de code à saisir tout en montrant comment les définitions de fonctions, les paramètres, les types de retour, les expressions et les appels s’articulent.

Renvoyer une valeur depuis une fonction

Dans cette étape, vous allez compléter une fonction qui convertit des minutes en secondes et relier sa définition à son appel.

Accédez au projet préparé et ouvrez son fichier source :

cd /home/labex/project/conversion-tool

nano src/main.rs

Au début du fichier, la ligne suivante commence une définition de fonction :

fn minutes_to_seconds(minutes: i32) -> i32 {

fn introduit une fonction.
minutes_to_seconds est le nom de la fonction.
minutes: i32 est un paramètre : une entrée nommée minutes, dont le type est l’entier i32.
-> i32 indique que la fonction renvoie une valeur de type i32.
Les accolades contiennent le corps de la fonction.

Rust vérifie chaque appel par rapport à cette signature. L’appelant doit fournir le nombre d’arguments attendu, dans l’ordre déclaré, et chaque argument doit avoir un type compatible.

Remplacez uniquement le 0 situé avant le commentaire de l’étape 1 par :

    minutes * 60 // Step 1: replace this placeholder expression.

Remarquez que minutes * 60 ne comporte pas de point-virgule. Il s’agit de l’expression finale du corps de la fonction ; sa valeur devient donc la valeur renvoyée par la fonction. Ajouter un point-virgule la transformerait en instruction qui ne renverrait pas cette valeur.

Enregistrez avec Ctrl+O, appuyez sur Entrée, puis quittez avec Ctrl+X. Vérifiez le code :

cargo check

Dans main, minutes_to_seconds(5) est un appel de fonction. La valeur 5 est l’argument fourni au paramètre minutes. Exécutez le programme :

cargo run --quiet

Sa première ligne doit maintenant être :

5 minutes = 300 seconds

Utiliser un paramètre et un type de retour décimaux

Dans cette étape, vous allez compléter une deuxième fonction qui accepte et renvoie des valeurs à virgule flottante.

Ouvrez le fichier source :

nano src/main.rs

Recherchez celsius_to_fahrenheit. Son paramètre et son type de retour sont tous deux f64, ce qui permet de conserver un résultat fractionnaire. L’expression temporaire celsius * 0.0 utilise le paramètre, mais renvoie volontairement zéro. Remplacez toute cette expression par :

    celsius * 9.0 / 5.0 + 32.0 // Step 2: replace this placeholder expression.

Il s’agit également d’un retour par expression : la valeur calculée est le dernier élément du corps de la fonction et ne comporte pas de point-virgule. La multiplication et la division sont évaluées avant l’addition, conformément aux règles habituelles de priorité arithmétique. Les parenthèses peuvent rendre explicite un ordre de calcul plus complexe. L’appelant n’a pas besoin de connaître la formule : il fournit une température en degrés Celsius et reçoit la valeur renvoyée en degrés Fahrenheit.

Enregistrez le fichier, quittez l’éditeur, puis exécutez le programme :

cargo run --quiet

La deuxième ligne doit être :

20.0 C = 68.0 F

L’appel celsius_to_fahrenheit(20.0) transmet un argument. La valeur renvoyée est stockée dans la liaison fahrenheit avant d’être formatée pour l’affichage.

Réutiliser une fonction avec plusieurs arguments

Dans cette étape, vous allez compléter une fonction comportant deux paramètres et observer deux appels qui la réutilisent.

La fonction scale_amount préparée reçoit amount et factor. Les paramètres sont séparés par des virgules et chacun possède son propre type. Un appel doit fournir les arguments dans le même ordre.

Ouvrez le fichier et recherchez l’expression fictive de l’étape 3 :

nano src/main.rs

L’expression temporaire amount * factor * 0.0 renvoie volontairement zéro. Remplacez toute cette expression par :

    amount * factor // Step 3: replace this placeholder expression.

Enregistrez le fichier et quittez l’éditeur, puis effectuez une dernière vérification :

cargo check

Exécutez le programme terminé :

cargo run --quiet

La même fonction est appelée une fois pour la farine et une fois pour l’eau. Les deux dernières lignes doivent être :

Scaled flour: 375.0 g
Scaled water: 270.0 ml

C’est le principal avantage d’une fonction : le calcul est défini une seule fois, reçoit un nom explicite, puis est réutilisé avec différents arguments.

Résumé

Vous avez complété des fonctions utilisant des paramètres entiers et à virgule flottante, lu les flèches indiquant les types de retour, renvoyé des valeurs avec des expressions finales, transmis des arguments lors des appels de fonctions et réutilisé une fonction pour plusieurs calculs.