Comprendre les fonctions dans Rust

Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

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.

comment copier des dvds sur le disque dur

UTILISEZ LA VIDÉO DU JOUR

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 .

 // function that neither takes in arguments nor returns a value 
fn function_name() { 
    // function body here 
}

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

 fn a_function(){ 
    let 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 :

 fn name() 
 
fn greet(name: &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 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 comme arguments :

bruit de ventilateur d'ordinateur portable hp windows 10

 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 function_name(arg: type, arg2: type) -> (type, type) { 
    // function body here 
    return 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 string_and_integer(s: String, n: i32) -> (String, i32) { 
    return (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.

comment vérifier votre carte graphique windows 10

 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 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 main() { 
    let result = add_numbers(3, 5); 
    println!("The result is {}", result); // Output: The result is 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 .

Exemple de résultat de l'appel de fonctions Rust

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.