Fonctions de rouille

Ce guide explorera comment créer et utiliser des fonctions dans le langage de programmation Rust. Les fonctions sont une caractéristique universelle dans la plupart des langages de programmation et fondamentaux pour que tout développeur sache.

Qu'est-ce qu'une fonction?

Avant d'entrer dans les détails de la création et de l'utilisation d'une fonction, décomposons ce qu'est une fonction et pourquoi l'utiliser.

Une fonction n'est rien de plus qu'un ou plusieurs blocs de code qui sont regroupés et effectue une seule entité. Les fonctions sont une fonctionnalité lourde dans la plupart des langages de programmation car ils nous permettent d'organiser et d'exporter du code vers d'autres parties du programme dans un modèle lisible.

À ce jour, vous avez rencontré la fonction principale de la langue de la rouille. La fonction principale est un type spécial de fonction qui sert de point d'entrée pour un programme de rouille.

Avec cela à l'écart, discutons de la façon de créer et d'utiliser des fonctions dans la rouille.

Fonctions de rouille

Voici les étapes à prendre lors de la définition d'une fonction de rouille.

1. Nous commençons par le mot-clé FN.
2. Ensuite, nous définissons le nom de la fonction.
3. Une paire de parenthèses et transmet une liste de paramètres.
4. Définissez un corps de fonction à l'aide d'ouverture et de fermeture des accolades bouclées.
5. Enfin, une valeur de retour (si disponible).

Nous pouvons exprimer le code ci-dessus dans la syntaxe ci-dessous:

fnfunction_name (paramètres)
// Corps de fonction

Le type de fonction le plus élémentaire est celui qui n'accepte aucun paramètre ni ne contient une valeur de retour. Nous pouvons définir une telle fonction comme indiqué dans l'exemple ci-dessous:

fn say_hello ()
println!("Bonjour le monde");

Ce qui précède illustre le concept le plus fondamental d'une définition de fonction. Nous commençons par le mot-clé FN suivi du nom de la fonction, dans notre cas, say_hello (). Nous ouvrons ensuite le corps de la fonction à l'intérieur d'une paire de bretelles bouclées.

Le corps de fonction ne contient que la logique de ce que fait la fonction. Parfois, une fonction appellera d'autres fonctions et les utilisera.

Appeler une fonction

Une fois que nous avons déclaré une fonction, nous pouvons l'utiliser pour effectuer les actions définies. Nous nous référons au processus d'utilisation d'une fonction comme appel de fonction ou invoquant une fonction.

Dans Rust, nous appelons une fonction en fournissant son nom et une paire de parenthèses. Cela indique au compilateur que nous souhaitons exécuter les instructions définies dans cette fonction.

Dans notre exemple, nous pouvons appeler notre fonction à l'intérieur de la fonction principale comme indiqué dans l'exemple ci-dessous:

fn main ()
//! Appeler la fonction
dis bonjour();

/// Déclaration de fonction
fn say_hello ()
println!("Bonjour le monde");

Paramètres de fonction

L'une des principales raisons de l'utilisation des fonctions est de passer les paramètres. Un paramètre est un type spécial de variable que nous pouvons transmettre à la fonction et permettre la modification de la logique que la fonction utilise.

Vous pouvez souvent entendre le paramètre de mot et l'argument des termes utilisés de manière interchangeable. Bien qu'ils aient une différence, ce n'est vraiment rien pour vous empêcher de construire des outils avec Rust.

Pour définir un ensemble de paramètres de fonction, nous commençons par définir le nom du paramètre suivi de son type à l'intérieur des parenthèses de la fonction.

La syntaxe est comme indiqué:

fn function_name (paramètre1: data_type)
// Corps de fonction

Remarque Vous devez effectuer l'annotation de type pour un paramètre de fonction.

Prenons la fonction Say_hello que nous avons définie plus tôt et l'améliorez afin qu'elle dise bonjour à l'utilisateur spécifique.

Nous pouvons faire:

fn Say_hello (nom: & str)
println!("Bonjour, ", nom);

Dans l'exemple ci-dessus, nous définissons un paramètre pour la fonction Say_hello de Type & Str. Nous pouvons maintenant passer un nom à la fonction, et il nous saluera avec le nom fourni.

Pour passer le paramètre pendant l'appel de fonction, nous pouvons faire:

fn main ()
Say_hello ("Sarah!");

fn Say_hello (nom: & str)
println!("Bonjour, ", nom);

Instruction et expression de la fonction

Comme mentionné, un corps de fonction comprend des instructions de code qui effectuent une action. Nous avons utilisé une macro définie pour imprimer quelque chose à l'écran dans notre exemple. Cependant, nous pouvons créer une logique personnalisée pour nos fonctions.

Par exemple, prenez la fonction ci-dessous qui prend deux entiers et renvoyez le maximum des deux:

fnmaximum (x: i32, y: i32)
Soit mut max = 0;
Si x> y
max = x;
autre
max = y;

println!("La valeur max est: ", max);

Nous pouvons ensuite appeler la fonction et passer les deux valeurs entières comme indiqué ci-dessous:

fn main ()
Maximum (100, 50);

L'exécution du code ci-dessus doit imprimer:

La valeur maximale est: 100

Valeurs de retour de fonction

Une fonction peut également renvoyer une valeur basée sur la logique et les actions qu'elle effectue. Nous pouvons ensuite utiliser la valeur renvoyée de la fonction pour effectuer d'autres opérations. Bien que nous ne nommez pas la valeur de retour dans une fonction, nous devons dire au compilateur que nous nous attendons à ce que la fonction renvoie une valeur d'un type spécifique.

Nous faisons cela en utilisant la flèche -> notation.

Prenez la fonction maximale () que nous avons définie plus tôt. Au lieu d'imprimer la valeur maximale, nous pouvons avoir la fonction renvoie la valeur maximale, et nous pouvons l'utiliser pour agir sur d'autres parties du programme.

Pour définir un type de retour de fonction, nous pouvons utiliser la syntaxe comme:

fn function_name (paramètre: type) -> return_type
// Corps de fonction

Considérez l'exemple ci-dessous qui redéfinit la fonction maximale pour inclure une valeur de retour:

fn maximum (x: i32, y: i32) -> i32
// logique

Dans ce cas, nous nous attendons à ce que la fonction renvoie un type i32.

Une fois que nous avons défini un type de retour de fonction, nous devons nous assurer que la fonction renvoie réellement quelque chose.

Nous pouvons le faire en utilisant le mot-clé de retour. Par exemple, pour renvoyer la valeur maximale de la fonction ci-dessus, nous pouvons faire:

fnmaximum (x: i32, y: i32) -> i32
Soit mut max = 0;
Si x> y
max = x;
autre
max = y;

retourner max;

La fonction doit renvoyer la valeur de la variable max.

Un autre format que nous pouvons utiliser pour renvoyer une valeur à partir d'une fonction consiste à spécifier la valeur de retour sans terminateur semi-colon.

Un exemple est comme indiqué:

fnmain ()
Say_hello ("Sarah!");
Maximum (100, 50);

fnsay_hello (nom: & str)
println!("Bonjour, ", nom);

fnmaximum (x: i32, y: i32) -> i32
LetMut max = 0;
Si x> y
max = x;
autre
max = y;

// Pas de mot-clé ou de semi-colon
max

L'exemple ci-dessus doit se comporter de la même manière que le mot-clé de retour.

Nous pouvons ensuite utiliser la valeur renvoyée de la fonction pour effectuer une action. Par exemple:

fn main ()
println!("Produit: ", maximum (100, 10) * 2);

Ici, nous prenons la valeur renvoyée de la fonction maximale et le multiplions par 2.

De clôture

Pour ce tutoriel, nous avons exploré le concept de fonctions, comment définir une fonction, des paramètres de fonction, des valeurs de retour de fonction, et plus. Les fonctions sont un concept important dans la programmation, et ils nous permettent d'organiser et de réutiliser le code sans répétition.

Nous espérons que vous avez apprécié le tutoriel.

Au revoir!