Rust Basics Series #5 : Fonctions dans Rust

Comme tout langage de programmation moderne, Rust a aussi des fonctions.

La fonction que vous connaissez déjà est la main fonction. Cette fonction est appelée au lancement du programme.

Mais qu’en est-il des autres fonctions ? Dans cet article, vous apprendrez à utiliser les fonctions des programmes Rust.

La syntaxe de base d’une fonction

Vous le savez peut-être déjà d’après la façon dont nous déclarons le main fonction, mais regardons néanmoins la syntaxe de déclaration d’une fonction.

// declaring the function
fn function_name() {
    <statement(s)>;
}

// calling the function
function_name();

Regardons une fonction simple qui imprime la chaîne “Salut!” à la sortie standard.

fn main() {
    greet();
}

fn greet() {
    println!("Hi there!");
}

Et comme prévu, il a la sortie suivante :

Hi there!

C’était simple. Passons au niveau supérieur. Créons des fonctions qui acceptent des paramètres et renvoient des valeurs. Ni l’un ni l’autre ne sont mutuellement exclusifs ou inclusifs.

Accepter des paramètres avec des fonctions

La syntaxe d’une fonction acceptant le paramètre est la suivante :

// declaring the function
fn function_name(variable_name: type) {
    <statement(s)>;
}

// calling the function
function_name(value);

Vous pouvez considérer les paramètres de la fonction comme un tuple passé à la fonction. Il peut accepter des paramètres de plusieurs types de données et autant que vous le souhaitez. Ainsi, vous n’êtes pas limité à accepter des paramètres du même type.

Contrairement à certaines langues, Rust n’a pas arguments par défaut. Remplir tous les paramètres lors de l’appel de la fonction est obligatoire.

Exemple : fonction Faim

Regardons un programme pour mieux comprendre cela.

fn main() {
    food(2, 4);
}

fn food(theplas: i32, rotis: i32) {
    println!(
        "I am hungry... I need {} theplas and {} rotis!",
        theplas, rotis
    );
}

A la ligne 5, je déclare une fonction appelée food. Cette fonction prend en compte 2 paramètres : theplas et rotis (Noms des produits alimentaires indiens). J’imprime ensuite le contenu de ces variables.

Du main fonction, j’appelle la food fonction avec les paramètres ‘2’ et ‘4’. Cela signifie que theplas reçoit la valeur ‘2’ et rotis se voir attribuer la valeur ‘4’.

Regardons la sortie du programme :

I am hungry... I need 2 theplas and 4 rotis!

Et maintenant j’ai vraiment faim… 😋

Renvoyer des valeurs d’une fonction

Tout comme une fonction peut accepter des valeurs sous forme de paramètres, une fonction peut également renvoyer une ou plusieurs valeurs. La syntaxe d’une telle fonction est la suivante :

// declaring the function
fn function_name() -> data_type {
    <statement(s)>;
}

// calling the function
let x = function_name();

La fonction peut renvoyer une valeur en utilisant soit le return mot-clé ou en utilisant une expression au lieu d’une instruction.

Attendez! Expression quoi ?

Avant d’aller plus loin : Déclarations vs Expressions

Cela peut ne pas correspondre au flux des exemples de fonctions Rust, mais vous devez comprendre la différence entre les instructions et les expressions dans Rust et dans d’autres langages de programmation.

Une instruction est une ligne de code qui se termine par un point-virgule et n’évalue pas à une certaine valeur. Une expression, en revanche, est une ligne de code qui ne se termine pas par un point-virgule et qui prend une certaine valeur.

Comprenons cela avec un exemple:

fn main() {
    let a = 873;
    let b = {
        // statement
        println!("Assigning some value to a...");

        // expression
        b * 10
    };

    println!("a: {a}");
}

À la ligne 3, j’ouvre un bloc de code, à l’intérieur duquel j’ai une déclaration et une expression. Les commentaires mettent en évidence lequel est lequel.

Le code sur le 5^e La ligne n’est pas évaluée à une valeur et doit donc se terminer par un point-virgule. Ceci est une déclaration.

Le code du 8^e la ligne est évaluée à une valeur. C’est b * 10 lequel est 873 * 10 et il s’évalue à 8730. Comme cette ligne ne se termine pas par un point-virgule, il s’agit d’une expression.

Exemple : acheter des fruits rouillés

Comprenons comment une fonction renvoie une valeur à l’aide d’une démonstration.

fn main() {
    println!(
        "If I buy 2 Kilograms of apples from a fruit vendor, I have to pay {} rupees to them.",
        retail_price(2.0)
    );
    println!(
        "But, if I buy 30 Kilograms of apples from a fruit vendor, I have to pay {} rupees to them.",
        wholesale_price(30.0)
    );
}

fn retail_price(weight: f64) -> f64 {
    return weight * 500.0;
}

fn wholesale_price(weight: f64) -> f64 {
    weight * 400.0
}

Au-dessus, j’ai deux fonctions: retail_price et wholesale_price. Les deux fonctions acceptent un paramètre et stockent la valeur dans le weight variable. Cette variable est de type f64 et la signature de la fonction indique qu’un f64 La valeur est finalement renvoyée par la fonction.

Ces deux fonctions multiplient le poids des pommes achetées par un nombre. Ce nombre représente le prix actuel par kilogramme pour les pommes. Étant donné que les acheteurs en gros ont de grosses commandes, la logistique est en quelque sorte plus facile, le prix peut être un peu allégé.

Outre le prix au kilogramme, les fonctions ont une autre différence. C’est le retail_price la fonction retourne le produit en utilisant la return mot-clé. Tandis que le wholesale_price La fonction renvoie le produit à l’aide d’une expression.

If I buy 2 Kilograms of apples from a fruit vendor, I have to pay 1000 rupees to them.
But, if I buy 30 Kilograms of apples from a fruit vendor, I have to pay 12000 rupees to them.

La sortie montre que les deux méthodes de retour d’une valeur à partir d’une fonction fonctionnent comme prévu.

Renvoyer plusieurs valeurs

Vous pouvez avoir une fonction qui renvoie plusieurs valeurs de différents types. Vous avez de nombreuses options, mais retourner un tuple est le plus simple.

Voici un exemple :

fn main() {
    let (maths, english, science, sanskrit) = tuple_func();

    println!("Marks obtained in Maths: {maths}");
    println!("Marks obtained in English: {english}");
    println!("Marks obtained in Science: {science}");
    println!("Marks obtained in Sanskrit: {sanskrit}");
}

fn tuple_func() -> (f64, f64, f64, f64) {
    // return marks for a student
    let maths = 84.50;
    let english = 85.00;
    let science = 75.00;
    let sanskrit = 67.25;

    (maths, english, science, sanskrit)
}

Le tuple_func renvoie quatre f64 valeurs, enfermées dans un tuple. Ces valeurs sont les notes obtenues par un élève dans quatre matières (sur 100).

Lorsque la fonction est appelée, ce tuple est renvoyé. Je peux soit imprimer les valeurs en utilisant tuple_name.0 schéma, mais j’ai pensé qu’il valait mieux détruire le tuple en premier. Cela atténuera la confusion quant à savoir quelle valeur est laquelle. Et j’imprime les marques en utilisant les variables qui contiennent des valeurs du tuple déstructuré.

Voici la sortie que j’obtiens :

Marks obtained in Maths: 84.5
Marks obtained in English: 85
Marks obtained in Science: 75
Marks obtained in Sanskrit: 67.25

Conclusion

Cet article couvre les fonctions du langage de programmation Rust. Les “types” de fonctions sont couverts ici :

• Fonctions qui n’acceptent aucun paramètre(s) ni valeur(s) de retour
• Fonctions acceptant un ou plusieurs paramètres
• Fonctions qui renvoient une ou plusieurs valeurs à l’appelant

Vous savez ce qui vient ensuite? Les instructions conditionnelles alias if-else dans Rest. Restez à l’écoute et amusez-vous à apprendre Rust avec It’s FOSS.