Fonctions Rust

Les fonctions sont omniprésentes dans le langage Rust.

Grâce aux chapitres précédents, nous avons déjà pu comprendre la forme de base des fonctions Rust :

fn <nom_fonction> ( <paramètres> ) <corps_fonction>

Dans Rust, le style de nommage des noms de fonctions est en minuscules avec des traits de soulignement :

fn　main()　{
　　　　println!("Hello, world!");
　　　　another_function();
}
fn another_function() {
　　　　println!("Hello, w3codebox!);
}

Résultat de l'exécution :

Hello, world!
Hello, w3codebox!

Notez que nous avons défini another_function après la fonction main dans le code source. Rust ne se soucie pas de l'endroit où vous définissez les fonctions, tant qu'elles sont définies quelque part.

Paramètres de la fonction

En Rust, pour définir une fonction qui nécessite des paramètres, il est nécessaire de déclarer le nom et le type des paramètres :

fn　main()　{
　　　　another_function(5,　6;
}
fn another_function(x: i32, y: i32) {
　　　　println!("La valeur de x est : {}", x);
　　　　println!("La valeur de y est : {}", y);
}

Résultat de l'exécution :

La valeur de x est :　5
La valeur de y est :　6

Instructions et expressions du corps de la fonction

Le corps d'une fonction Rust est composé d'une série d'instructions (Statement) qui peuvent se terminer par une expression (Expression). Jusqu'à présent, nous avons seulement vu des fonctions sans expression de fin, mais nous avons utilisé l'expression comme partie d'une instruction.

Une instruction est une étape qui exécute certaines opérations sans retourner de valeur. Par exemple :

let a =　6;

Cette étape ne retourne aucune valeur, donc l'instruction suivante est incorrecte :

let a = (let b =　2;

L'expression a des étapes de calcul et une valeur de retour. Voici l'expression (hypothèse : les identifiants mentionnés ont été définis) :

a　=　7
b　+　2
c　*　(a　+　b)

En Rust, vous pouvez écrire une expression plus complexe dans un bloc entouré de {} :

fn　main()　{
　　　　let　x　=　5;
　　　　let　y　=
　　　　　　　　let　x　=　3;
　　　　　　　　x　+　1
　　　　};
　　　　println!("La valeur de x est : {}", x);
　　　　println!("La valeur de y est : {}", y);
}

Résultat de l'exécution :

La valeur de x est :　5
La valeur de y est :　4

Il est évident que ce programme contient un bloc d'expression :

{
　　　　let　x　=　3;
　　　　x　+　1
};

De plus, vous pouvez utiliser des instructions de fonction dans le bloc, la dernière étape est l'expression, la valeur de cette expression est la valeur de l'expression de bloc entière. Ce type d'expression de bloc s'appelle l'expression de corps de fonction.

Attention : x + 1 Il n'y a pas de point-virgule à la fin, sinon il deviendra une instruction !

Cette expression de bloc est un corps de fonction légal. De plus, en Rust, la définition de fonction peut être imbriquée :

fn　main()　{
　　　　fn　five()　->　i32　{
　　　　　　　　5
　　　　}
　　　　println!("La valeur de five() est : {}", five());
}

Retour de la fonction

Dans l'exemple de l'instance imbriquée précédente, la manière de déclarer le type de retour de la fonction Rust a été montrée : après la déclaration des paramètres en utilisant -> pour déclarer le type de retour de la fonction (pas : ).

Dans le corps de la fonction, vous pouvez à tout moment terminer l'exécution de la fonction avec le mot-clé return et retourner une valeur appropriée. C'est aussi la méthode la plus proche de l'expérience de la plupart des développeurs :

fn　add(a:　i32,　b:　i32)　->　i32　{
　　　　return　a　+　b;
}

Mais Rust ne prend pas en charge la détection automatique du type de retour de valeur ! Si le type de retour de la fonction n'est pas explicitement déclaré, la fonction sera considérée comme "procedurale pure", ne pouvant pas produire de valeur de retour, et il ne peut pas y avoir d'expression de retour après return.

Attention :L'expression du corps de la fonction ne peut pas être égale au corps de la fonction, elle ne peut pas utiliser return Mots-clés.