Comprendre les fonctions dans Rust

Les fonctions sont des constructions de programmation essentielles car elles jettent 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. Ils peuvent recevoir une entrée, sous forme d'arguments, et renvoyer une valeur.

Rust fournit des fonctions pour l'organisation, l'encapsulation et la réutilisation du code.

Définir des fonctions dans Rust

Les fonctions de rouille ressemblent beaucoup à Fonctionne dans n'importe quel autre langage de programmation, bien qu'il existe de petites différences que vous devrez comprendre.

Vous définirez des fonctions pour vos programmes Rust avec le fn mot-clé suivi du nom de la fonction, d'arguments facultatifs et d'un retour facultatif Type de données.

// fonction qui ne prend pas d'arguments ni ne renvoie de valeur
fn nom_fonction() {
// corps de la fonction ici
}

Voici une simple fonction Rust qui ne prend aucun argument et ne renvoie aucune valeur.

fn une_fonction(){
 soit x = 3;
println!("{}", X)
}

une fonction est une simple fonction Rust qui imprime la variable X.

Signatures de fonction de rouille

Les signatures de fonction sont un moyen de nommer les fonctions et de décrire leurs arguments et types de retour, sans inclure de corps de fonction. Les signatures de fonction sont utiles pour documenter les API des bibliothèques Rust.

Voici un exemple de signature de fonction Rust :

nom fn()
fn saluer (nom: &str)

Le nom fonction est une signature de fonction minimale, tandis que la saluer signature spécifie que la fonction prend un seul argument, nom, de type chaîne (&str).

Déclarer des fonctions avec des arguments et des valeurs de retour

Les fonctions Rust peuvent prendre de nombreux arguments et la limite n'est pas explicitement définie. Les fonctions avec arguments sont généralement plus flexibles car elles peuvent prendre des valeurs d'autres fonctions et parties de code.

Voici le modèle typique d'une fonction Rust qui prend des arguments :

fn nom_fonction (arg: taper, arg2: taper) {
// corps de la fonction ici
}

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 comme arguments :

fn add_numbers (x: i32, y: i32) {
println!("{}", x + y);
}

Le add_numbers La fonction prend deux entiers 32 bits et imprime la somme des entiers.

Les fonctions Rust peuvent renvoyer plusieurs valeurs; vous devrez spécifier le ou les types de retour et renvoyer les valeurs du type à partir de la fonction.

fn nom_fonction (arg: taper, arg2: taper) -> (taper, taper) {
// corps de la fonction ici
retour arg, arg2
}

Voici une fonction qui prend une chaîne et un entier 32 bits comme argument et renvoie les arguments sous forme de tuple.

fn chaîne_et_entier (s: chaîne, n: i32) -> (chaîne, i32) {
retour (s, n);
}

Le chaîne_et_entier La fonction prend une chaîne et un entier 32 bits, les renvoyant sous forme de tuple. Vous ne pouvez renvoyer qu'une seule valeur à partir d'une fonction Rust.

Vous pouvez laisser de côté le retour mot clé lors du retour de l'expression finale d'une fonction, pour rendre le code plus concis.

fn chaîne_et_entier (s: chaîne, n: i32) -> (chaîne, i32) {
retour (s, n);
}
// les fonctions sont équivalentes
fn str_and_int (s: chaîne, n: i32) -> (chaîne, i32) {
 (s, n)
}

Ces deux fonctions ont le même comportement car elles acceptent toutes deux une chaîne et un entier et renvoient ces arguments sous forme de tuple.

Appel de fonctions Rust

Vous pouvez appeler une fonction à partir d'une autre en écrivant son nom suivi des valeurs que vous souhaitez lui transmettre entre parenthèses :

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn principal() {
 laisser result = add_numbers(3, 5);
println!("Le résultat est {}", résultat); // Sortie: Le résultat est 8
}

Le principal appels de fonction add_numbers, en lui passant deux entiers. Il 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 peut y accéder et la modifier.

Rust n'est pas purement orienté objet, mais il fournit des structures pour regrouper les données liées. Vous pouvez travailler à la mise en œuvre des concepts OOP dans Rust en utilisant des structures avec des méthodes.