Les fonctions sont des constructions de programmation essentielles car elles posent les bases de la réutilisation du code et facilitent la programmation modulaire. Les fonctions sont des blocs de code autonomes qui exécutent des tâches spécifiques. Elles peuvent recevoir des données, sous forme d’arguments, et renvoyer une valeur.
Rust fournit des fonctions pour l’organisation, l’encapsulation et la réutilisation du code.
Définition des fonctions en Rust
Les fonctions Rust ressemblent beaucoup aux fonctions de n’importe quel autre langage de programmation, bien qu’il y ait quelques petites différences qu’il vous faudra comprendre.
Vous définirez les fonctions de vos programmes Rust à l’aide de la fonction fn suivi du nom de la fonction, d’arguments facultatifs et d’un type de données de retour facultatif.
// function that neither takes in arguments nor returns a value
fn function_name() {
// function body here
}
Voici une fonction Rust simple qui ne prend aucun argument et ne renvoie aucune valeur.
fn a_function(){
let x = 3;
println!("{}", x)
}
a_fonction est une simple fonction Rust qui imprime la variable x.
Signatures de fonctions Rust
Les signatures de fonction sont un moyen de nommer les fonctions et de décrire leurs arguments et leurs types de retour, sans inclure le corps de la fonction. Les signatures de fonction sont utiles pour documenter les API des bibliothèques Rust.
Voici un exemple de signature de fonction Rust :
fn name()
fn greet(name: &str)
La fonction nom est une signature de fonction minimale, tandis que la fonction saluer La signature spécifie que la fonction prend un seul argument, nom, de type chaîne de caractères (&str).
Déclarer des fonctions avec arguments et valeurs de retour
Les fonctions Rust peuvent recevoir de nombreux arguments, et la limite n’est pas explicitement définie. Les fonctions avec arguments sont généralement plus flexibles puisqu’elles peuvent prendre des valeurs provenant d’autres fonctions et parties du code.
Voici le modèle typique d’une fonction Rust qui prend des arguments :
fn function_name(arg: type, arg2: type) {
// function body here
}
Le type d’argument de la fonction peut être un type intégré à Rust ou un type personnalisé de votre programme.
Voici un exemple de fonction simple qui prend deux entiers en argument :
fn add_numbers(x: i32, y: i32) {
println!("{}", x + y);
}
Le numéros_ajoutés prend en compte deux nombres entiers de 32 bits et imprime la somme des nombres entiers.
Les fonctions Rust peuvent renvoyer plusieurs valeurs ; vous devrez spécifier le(s) type(s) de retour et renvoyer les valeurs du type à partir de la fonction.
fn function_name(arg: type, arg2: type) -> (type, type) {
// function body here
return arg, arg2
}
Voici une fonction qui prend en argument une chaîne de caractères et un entier 32 bits et renvoie les arguments sous forme de tuple.
fn string_and_integer(s: String, n: i32) -> (String, i32) {
return (s, n);
}
La fonction chaîne_et_intégrale prend en charge une chaîne de caractères et un entier de 32 bits et les renvoie sous la forme d’un tuple. Une fonction Rust ne peut renvoyer qu’une seule valeur.
Vous pouvez omettre l’élément retour lors du retour de l’expression finale d’une fonction, afin de rendre le code plus concis.
fn string_and_integer(s: String, n: i32) -> (String, i32) {
return (s, n);
}
// the functions are equivalent
fn str_and_int(s: String, n: i32) -> (String, i32) {
(s, n)
}
Ces deux fonctions ont le même comportement puisqu’elles prennent toutes deux une chaîne de caractères et un entier et renvoient ces arguments sous la forme d’un tuple.
Appeler des fonctions Rust
Vous pouvez appeler une fonction à partir d’une autre en écrivant son nom suivi des valeurs que vous voulez lui passer entre parenthèses :
fn add_numbers(x: i32, y: i32) -> i32 {
x + y
}
fn main() {
let result = add_numbers(3, 5);
println!("The result is {}", result); // Output: The result is 8
}
La fonction principal appels de fonction add_numbersen lui transmettant deux nombres entiers. Elle affecte le résultat de la fonction à une variable, résultat.
Vous pouvez déclarer des fonctions pour les structures Rust
Vous pouvez déclarer des fonctions dans les structures Rust. Celles-ci deviennent des méthodes pour la structure qui peuvent y accéder et la modifier.
Rust n’est pas purement orienté objet, mais il fournit des structures pour regrouper des données connexes. Vous pouvez travailler à l’implémentation de concepts OOP en Rust en utilisant des structures avec des méthodes.
