Learn Rust Coding · Leçon

Modules et mod

Organiser le code

Modules et mod 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.

Pourquoi des modules ?

À mesure que les programmes grandissent, tout mettre dans un seul fichier devient désordonné. Les modules permettent de regrouper le code associé, de contrôler ce qui est public et d’éviter les conflits de noms.

Le mot-clé mod déclare un module.

Déclarer un module intégré

Vous pouvez définir un module directement dans un fichier avec mod name { ... }. Tout ce qui se trouve entre les accolades appartient à ce module.

mod greetings {
    fn hello() {
        println!("hello from the module");
    }
}

fn main() {
    println!("module declared above");
}

Appeler les fonctions d’un module

Les éléments d’un module sont privés par défaut. Pour en appeler un depuis l’extérieur, il doit être pub, et vous le référencez avec le chemin du module en utilisant ::.

mod greetings {
    pub fn hello() {
        println!("hello!");
    }
}

fn main() {
    greetings::hello();
}

Modules imbriqués

Les modules peuvent contenir d’autres modules et former ainsi un arbre. Le chemin énumère chaque niveau, séparé par ::.

mod app {
    pub mod ui {
        pub fn draw() {
            println!("drawing ui");
        }
    }
}

fn main() {
    app::ui::draw();
}

Les modules regroupent plus que des fonctions

Un module peut contenir des fonctions, des structures, des énumérations, des constantes et même d’autres modules. Les types et comportements associés restent ainsi regroupés.

mod shapes {
    pub struct Circle {
        pub radius: f64,
    }
    pub const PI: f64 = 3.14159;
}

fn main() {
    let c = shapes::Circle { radius: 2.0 };
    println!("area = {}", shapes::PI * c.radius * c.radius);
}

L’arbre des modules

Chaque caisse possède un module racine. Les modules que vous déclarez forment un arbre en dessous de celui-ci. Les chemins indiquent où se trouve un élément, comme les dossiers d’un système de fichiers.

super : le module parent

Dans un module, super désigne le module parent. Il permet à un module enfant d’appeler un élément défini un niveau plus haut.

fn top_level() {
    println!("called via super");
}

mod inner {
    pub fn run() {
        super::top_level();
    }
}

fn main() {
    inner::run();
}

self : le module actuel

self désigne le module actuel. Il sert principalement à préciser où se trouve un élément dans un chemin.

mod tools {
    pub fn helper() {
        println!("helper running");
    }
    pub fn run() {
        self::helper();
    }
}

fn main() {
    tools::run();
}

Modules dans des fichiers séparés

En plus des modules intégrés, mod network; (avec un point-virgule et sans corps) indique à Rust de charger le contenu depuis network.rs ou network/mod.rs.

C’est ainsi que les projets réels répartissent le code entre plusieurs fichiers tout en conservant un seul arbre de modules.

Limites de confidentialité

Les modules forment des limites de confidentialité. Un module enfant peut voir les éléments privés de ses ancêtres, mais les parents ne peuvent pas accéder aux éléments privés d’un enfant.

Cette encapsulation masque les détails internes.

mod bank {
    fn secret() -> i32 { 42 }
    pub fn reveal() -> i32 { secret() }
}

fn main() {
    println!("{}", bank::reveal());
}

Organiser des projets réels

Utilisez les modules pour refléter votre domaine : auth, db, handlers. Gardez chacun d’eux ciblé, exposez une petite interface publique et masquez le reste.

Des limites claires entre les modules facilitent la navigation dans les grandes bases de code.

Vérification rapide

Testez vos connaissances des modules.

Récapitulatif

Vous avez appris à organiser le code avec des modules :

mod name { ... } déclare un module intégré
Les éléments sont privés par défaut ; utilisez pub pour les exposer
Les chemins utilisent :: pour parcourir l’arbre des modules
super, self et mod name; permettent de parcourir et de répartir les modules

Questions Fréquemment Posées

La leçon « Modules et mod » est-elle gratuite ?

Oui — le texte complet de « Modules et mod » 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 « Modules et mod » ?

Organiser le code 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 « Modules et mod » ?

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