Learn Rust Coding · Leçon

Organiser le code avec des modules

Apprenez à utiliser le système de modules de Rust pour regrouper logiquement le code, gérer la confidentialité et rendre vos projets évolutifs.

Organiser le code avec des modules est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. 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 3 leçons au total.

Organiser votre code avec des modules

À mesure que vos projets Rust grandissent, conserver tout votre code dans un seul fichier devient désordonné. Le système de modules de Rust vous aide à organiser votre code en unités logiques.

Les modules sont comme des dossiers pour votre code. Ils regroupent les fonctions, structures, énumérations et constantes associées, ce qui améliore la lisibilité et la facilité de maintenance.

Déclarer votre premier module

Vous déclarez un module à l'aide du mot-clé mod, suivi du nom du module. C'est comme créer un sous-espace de noms dans votre programme.

Créons un module greetings simple :

mod greetings {
    // This is where greeting functions would go
}

fn main() {
    println!("Hello from main!");
}

Comprendre la confidentialité des modules

Par défaut, tout ce qui se trouve dans un module est privé. Cela signifie que vous ne pouvez pas y accéder depuis l'extérieur du module sans le rendre explicitement public.

Si vous essayez d'appeler une fonction privée, Rust vous indiquera une erreur de compilation. Essayez de supprimer les commentaires de la ligne ci-dessous et de l'exécuter :

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

fn main() {
    // Uncomment the line below and try to run!
    // greetings::hello();
    println!("Main function running.");
}

Rendre des éléments publics avec `pub`

Pour rendre un élément (comme une fonction, une structure ou une énumération) visible depuis l'extérieur de son module, vous utilisez le mot-clé pub.

pub fn rend une fonction publique.
pub struct rend une structure publique.
pub mod rend un sous-module public, ce qui permet d'accéder à son contenu.

La confidentialité est un élément essentiel de la sécurité et de l'organisation de Rust !

`pub` en action

Rendons maintenant notre fonction hello publique à l'aide de pub. Cela permet à la fonction main de l'appeler sans erreur de confidentialité.

Exécutez ce code pour voir le message d'accueil de notre module :

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

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

Simplifier les chemins avec `use`

Écrire des chemins complets comme greetings::hello() peut devenir répétitif. Le mot-clé use vous permet d'introduire des éléments dans la portée, afin de les référencer plus facilement.

C'est similaire à import en Python ou à using en C#. Vous pouvez introduire dans la portée un élément spécifique ou un module entier.

`use` en action

Voici comment utiliser use pour raccourcir le chemin vers notre fonction hello. Remarquez que nous n'avons plus besoin du préfixe greetings::.

Votre code est ainsi plus propre et plus facile à lire.

mod greetings {
    pub fn hello() {
        println!("Hello, module user!");
    }
}

use greetings::hello; // Bring `hello` into scope

fn main() {
    hello(); // Now we can call it directly
}

Modules imbriqués et chemins relatifs

Les modules peuvent être imbriqués ! Vous pouvez définir des modules à l'intérieur d'autres modules pour une organisation encore plus précise. Pour y naviguer, Rust fournit super et self.

super fait référence au module parent.
self fait référence au module actuel.

Ils sont utiles pour les chemins relatifs au sein de hiérarchies de modules complexes.

mod outer {
    pub mod inner {
        pub fn call_me() {
            println!("Called from inner module!");
        }
    }

    pub fn call_inner() {
        // Accessing inner module from parent
        inner::call_me();
    }
}

fn main() {
    outer::call_inner();
    outer::inner::call_me();
}

Modules et structure des fichiers

Pour les modules plus volumineux, vous pouvez placer leur code dans des fichiers distincts. Rust recherche automatiquement les définitions de modules à des emplacements précis :

Pour mod my_module; dans src/main.rs : Rust recherche src/my_module.rs ou src/my_module/mod.rs.
Cela permet de garder votre fichier principal propre et de déléguer le contenu aux fichiers appropriés.

Cette leçon utilise des fichiers uniques par souci de simplicité, mais retenez ce principe pour les projets plus importants !

Vérification de l'accès aux modules

Examinez le code Rust suivant. Quelles lignes seront compilées sans erreur de confidentialité ?

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

    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }

    mod advanced {
        pub fn multiply(a: i32, b: i32) -> i32 {
            a * b
        }
    }
}

fn main() {
    // Line A
    // calculator::add(5, 3);

    // Line B
    // calculator::subtract(10, 4);

    // Line C
    // calculator::advanced::multiply(2, 6);

    // Line D
    // calculator::advanced::add(1, 1);
}

Modules : organiser et contrôler

Excellent travail ! Vous avez appris comment le système de modules de Rust vous aide à structurer votre code :

Utilisez mod pour déclarer des modules et des sous-modules.
Les éléments sont privés par défaut : utilisez pub pour les rendre accessibles.
use simplifie les longs chemins vers les éléments.
Les modules peuvent être répartis dans plusieurs fichiers pour les projets volumineux.

Les modules sont essentiels pour gérer la complexité en Rust. Continuez à pratiquer !

Questions Fréquemment Posées

La leçon « Organiser le code avec des modules » est-elle gratuite ?

Oui — le texte complet de « Organiser le code avec des modules » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Organiser le code avec des modules » ?

Apprenez à utiliser le système de modules de Rust pour regrouper logiquement le code, gérer la confidentialité et rendre vos projets évolutifs. 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 3.

Combien de temps prend la leçon « Organiser le code avec des modules » ?

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

Organiser le code avec des modules
Gérer les dépendances avec les caisses
Gestion robuste des erreurs avec `Result`

← Retour à Learn Rust Coding