Learn Rust Coding · Leçon

Définition de fonctions

Paramètres et valeurs de retour

Définition de fonctions est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Declaring a Function

You define a function with the fn keyword, a name, parentheses, and a body in curly braces.

Rust uses snake_case for function names by convention.

fn main() {
    greet();
}

fn greet() {
    println!("Hello from a function!");
}

The main Function

Every executable Rust program starts at fn main(). It is the entry point the runtime calls first.

fn main() {
    println!("Program starts here");
}

Parameters

Functions can take parameters. Each parameter must declare its type after a colon.

fn main() {
    print_number(7);
}

fn print_number(x: i32) {
    println!("The number is {}", x);
}

Multiple Parameters

Separate multiple parameters with commas. Each needs its own type annotation.

fn main() {
    describe("Rust", 2010);
}

fn describe(name: &str, year: i32) {
    println!("{} was released in {}", name, year);
}

Return Values

Declare a return type after an arrow ->. The function gives back a value of that type.

The last expression (with no semicolon) becomes the return value.

fn main() {
    let result = square(5);
    println!("square is {}", result);
}

fn square(n: i32) -> i32 {
    n * n
}

The return Keyword

You can also return early with the return keyword. This is useful for guard conditions.

fn main() {
    println!("{}", abs_value(-8));
}

fn abs_value(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

Combining Parameters and Returns

A function commonly takes inputs and produces an output. Here we add two numbers.

fn main() {
    let total = add(3, 4);
    println!("total {}", total);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Functions Calling Functions

Functions can call other functions, letting you build larger behavior from small reusable pieces.

fn main() {
    println!("{}", double_then_add(5));
}

fn double(n: i32) -> i32 { n * 2 }

fn double_then_add(n: i32) -> i32 {
    double(n) + 1
}

Returning Other Types

Functions can return any type: strings, booleans, tuples, and more.

fn main() {
    let (sum, product) = compute(3, 4);
    println!("sum {} product {}", sum, product);
}

fn compute(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

Functions With No Return

A function without an arrow returns the unit type (). It does its work through side effects like printing.

fn main() {
    log_message("saving file");
}

fn log_message(msg: &str) {
    println!("[LOG] {}", msg);
}

Order Does Not Matter

Unlike some languages, in Rust you can call a function defined later in the file. The compiler sees all functions before running.

fn main() {
    println!("{}", helper());
}

fn helper() -> i32 {
    99
}

Quick Check

Recall how Rust functions return values.

Recap

Functions in Rust:

Defined with fn name(params) -> ReturnType { ... }.
Parameters need explicit types.
The last expression (no semicolon) is the return value, or use return early.
No return type means it returns ().

fn main() {
    let area = rectangle_area(4, 6);
    println!("area {}", area);
}

fn rectangle_area(w: i32, h: i32) -> i32 {
    w * h
}

Questions Fréquemment Posées

La leçon « Définition de fonctions » est-elle gratuite ?

Oui — le texte complet de « Définition de fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Définition de fonctions » ?

Paramètres et valeurs de retour Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Définition de fonctions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding