Fonctions Rust

Les fonctions sont omniprésentes dans le langage Rust.

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

fn <函数名> ( <参数> ) <函数体>

Le style de nommage des fonctions Rust utilise des lettres minuscules séparées par des traits de soulignement :

Exemple

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

fn another_function() {
println!("Hello, example!");
}

Sortie :

Hello, world!
Hello, example!

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, vous devez simplement les définir quelque part.

Paramètres de fonction

En Rust, si une fonction a besoin de paramètres, vous devez déclarer les noms et les types des paramètres :

Exemple

fn main() {
another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
println!("La valeur de x est : {}", x);
println!("The value of y is: {}", y);
}

Sortie :

x 的值为 : 5
y 的值为 : 6

Instructions et expressions dans les corps de fonctions

Les corps de fonctions Rust sont constitués d'une série d'instructions (Statements) qui peuvent se terminer par une expression (Expression). Jusqu'à présent, nous n'avons vu que des fonctions qui ne se terminent pas par une expression, mais nous avons déjà utilisé des expressions comme partie d'instructions.

Une instruction est une étape qui effectue une action et n'a pas de valeur de retour. Par exemple :

let a = 6;

Cette étape n'a pas de valeur de retour, donc l'instruction suivante est incorrecte :

let a = (let b = 2);

Une expression comporte des étapes de calcul et une valeur de retour. Les éléments suivants sont des expressions (en supposant que les identifiants qui apparaissent ont déjà été définis) :

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

En Rust, vous pouvez utiliser un{}bloc délimité par {} pour écrire une expression plus complexe :

Exemple

fn main() {
let x = 5;

let y = {
let x = 3;
x + 1
};

println!("La valeur de x est : {}", x);
println!("The value of y is: {}", y);
}

Sortie :

x 的值为 : 5
y 的值为 : 4

Évidemment, ce programme contient un bloc d'expression :

{
    let x = 3;
    x + 1
};

De plus, des instructions de fonction peuvent être utilisées dans le bloc, et la dernière étape est une expression. La valeur de résultat de cette expression est la valeur représentée par le bloc d'expression entier. Ce type de bloc d'expression est appelé une expression de corps de fonction.

Remarque :x + 1Il n'y a pas de point-virgule après, sinon cela deviendra une instruction !

Ce type de bloc d'expression est un corps de fonction valide. De plus, en Rust, les définitions de fonctions peuvent être imbriquées :

Exemple

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

Valeurs de retour des fonctions

L'exemple imbriqué précédent a déjà montré la manière dont les fonctions Rust déclarent les types de valeur de retour : après les déclarations de paramètres, utilisez->pour déclarer le type de valeur de retour de la fonction (et non: ）。

Dans le corps de la fonction, vous pouvez utiliser le mot-clé return à tout moment pour terminer l'exécution de la fonction et renvoyer une valeur d'un type approprié. C'est également l'approche la plus proche de l'expérience de la plupart des développeurs :

Exemple

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

Cependant, Rust ne prend pas en charge l'inférence automatique du type de retour ! Si le type de retour de la fonction n'est pas déclaré explicitement, la fonction sera considérée comme une « procédure pure » et ne sera pas autorisée à produire une valeur de retour. Le mot-clé return ne peut pas être suivi d'une expression de valeur de retour. Le but de ceci est de permettre aux fonctions publiques de former un bulletin visible.

Remarque :Une expression de corps de fonction n'est pas équivalente à un corps de fonction ; elle ne peut pas utiliserreturnle mot-clé.

Autres extensions