Rouille - Fonctions

Les fonctions sont les éléments constitutifs d'un code lisible, maintenable et réutilisable. Une fonction est un ensemble d'instructions pour effectuer une tâche spécifique. Les fonctions organisent le programme en blocs logiques de code. Une fois définies, les fonctions peuvent être appelées pour accéder au code. Cela rend le code réutilisable. De plus, les fonctions facilitent la lecture et la maintenance du code du programme.

Une déclaration de fonction informe le compilateur du nom, du type de retour et des paramètres d'une fonction. Une définition de fonction fournit le corps réel de la fonction.

Sr. Non	Description de la fonction
1	Defining a function La définition de la fonction TA spécifie quoi et comment une tâche spécifique serait effectuée.
2	Calling or invoking a Function Une fonction doit être appelée pour l'exécuter.
3	Returning Functions Les fonctions peuvent également renvoyer la valeur avec le contrôle, de nouveau à l'appelant.
4	Parameterized Function Les paramètres sont un mécanisme permettant de transmettre des valeurs aux fonctions.

Définition d'une fonction

Une définition de fonction spécifie quoi et comment une tâche spécifique serait effectuée. Avant d'utiliser une fonction, elle doit être définie. Le corps de la fonction contient du code qui doit être exécuté par la fonction. Les règles de dénomination d'une fonction sont similaires à celles d'une variable. Les fonctions sont définies à l'aide dufnmot-clé. La syntaxe pour définir une fonction standard est donnée ci-dessous

Syntaxe

fn function_name(param1,param2..paramN) {
   // function body
}

Une déclaration de fonction peut éventuellement contenir des paramètres / arguments. Les paramètres sont utilisés pour transmettre des valeurs aux fonctions.

Exemple - Définition de fonction simple

//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Appel d'une fonction

Une fonction doit être appelée pour l'exécuter. Ce processus est appeléfunction invocation. Les valeurs des paramètres doivent être transmises lorsqu'une fonction est appelée. La fonction qui appelle une autre fonction est appeléecaller function.

Syntaxe

function_name(val1,val2,valN)

Exemple: appeler une fonction

fn main(){
   //calling a function
   fn_hello();
}

Ici, le main () est la fonction de l'appelant.

Illustration

L'exemple suivant définit une fonction fn_hello(). La fonction imprime un message sur la console. lemain()La fonction invoque la fonction fn_hello () .

fn main(){
   //calling a function
   fn_hello();
}
//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Production

hello from function fn_hello

Renvoyer la valeur d'une fonction

Les fonctions peuvent également renvoyer une valeur avec le contrôle, à l'appelant. Ces fonctions sont appelées fonctions de retour.

Syntaxe

L'une ou l'autre des syntaxes suivantes peut être utilisée pour définir une fonction avec un type de retour.

Avec déclaration de retour

// Syntax1
fn function_name() -> return_type {
   //statements
   return value;
}

Syntaxe abrégée sans instruction de retour

//Syntax2
fn function_name() -> return_type {
   value //no semicolon means this value is returned
}

lllustration

fn main(){
   println!("pi value is {}",get_pi());
}
fn get_pi()->f64 {
   22.0/7.0
}

Production

pi value is 3.142857142857143

Fonction avec paramètres

Les paramètres sont un mécanisme permettant de transmettre des valeurs aux fonctions. Les paramètres font partie de la signature de la fonction. Les valeurs des paramètres sont transmises à la fonction lors de son appel. Sauf indication contraire explicite, le nombre de valeurs passées à une fonction doit correspondre au nombre de paramètres définis.

Les paramètres peuvent être passés à une fonction en utilisant l'une des techniques suivantes -

Passer par valeur

Lorsqu'une méthode est appelée, un nouvel emplacement de stockage est créé pour chaque paramètre de valeur. Les valeurs des paramètres réels y sont copiées. Par conséquent, les modifications apportées au paramètre dans la méthode invoquée n'ont aucun effet sur l'argument.

L'exemple suivant déclare une variable no, qui vaut initialement 5. La variable est passée en paramètre (par valeur) au mutate_no_to_zero()function, qui change la valeur à zéro. Après l'appel de la fonction, lorsque le contrôle revient à la méthode principale, la valeur sera la même.

fn main(){
   let no:i32 = 5;
   mutate_no_to_zero(no);
   println!("The value of no is:{}",no);
}

fn mutate_no_to_zero(mut param_no: i32) {
   param_no = param_no*0;
   println!("param_no value is :{}",param_no);
}

Production

param_no value is :0
The value of no is:5

Passer par référence

Lorsque vous transmettez des paramètres par référence, contrairement aux paramètres de valeur, aucun nouvel emplacement de stockage n'est créé pour ces paramètres. Les paramètres de référence représentent le même emplacement mémoire que les paramètres réels fournis à la méthode. Les valeurs de paramètre peuvent être passées par référence en préfixant le nom de la variable avec un& .

Dans l'exemple donné ci-dessous, nous avons une variable no , qui est initialement 5. Une référence à la variable no est passée aumutate_no_to_zero()fonction. La fonction opère sur la variable d'origine. Après l'appel de fonction, lorsque le contrôle revient à la méthode principale, la valeur de la variable d'origine sera le zéro.

fn main() {
   let mut no:i32 = 5;
   mutate_no_to_zero(&mut no);
   println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(param_no:&mut i32){
   *param_no = 0; //de reference
}

L'opérateur * est utilisé pour accéder à la valeur stockée dans l'emplacement mémoire que la variable param_nopointe vers. Ceci est également connu sous le nom de déréférencement.

La sortie sera -

The value of no is 0.

Passer une chaîne à une fonction

La fonction main () transmet un objet chaîne à la fonction display () .

fn main(){
   let name:String = String::from("TutorialsPoint");
   display(name); 
   //cannot access name after display
}
fn display(param_name:String){
   println!("param_name value is :{}",param_name);
}

Production

param_name value is :TutorialsPoint