Organisation de fichiers Rust modulaire

Introduction

Dans ce laboratoire, la hiérarchie de fichiers des modules dans l'exemple de code peut être représentée comme suit : Il existe un répertoire nommé "my" qui contient deux fichiers, "inaccessible.rs" et "nested.rs". De plus, il existe un fichier nommé "my.rs" et un fichier nommé "split.rs". Le fichier "split.rs" inclut le module "my" qui est défini dans le fichier "my.rs", et le fichier "my.rs" inclut les modules "inaccessible" et "nested" qui sont définis respectivement dans les fichiers "inaccessible.rs" et "nested.rs".

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.

Hiérarchie de fichiers

Les modules peuvent être mappés à une hiérarchie de fichiers/répertoires. Analysons l'exemple de visibilité dans les fichiers :

$ tree.
.
├── my
│   ├── inaccessible.rs
│   └── nested.rs
├── my.rs
└── split.rs

Dans split.rs :

// Cette déclaration cherchera un fichier nommé `my.rs` et insérera
// son contenu dans un module nommé `my` dans ce contexte
mod my;

fn function() {
    println!("appelé `function()`");
}

fn main() {
    my::function();

    function();

    my::indirect_access();

    my::nested::function();
}

Dans my.rs :

// De même, `mod inaccessible` et `mod nested` trouveront les fichiers
// `nested.rs` et `inaccessible.rs` et les inséreront ici dans leurs
// modules respectifs
mod inaccessible;
pub mod nested;

pub fn function() {
    println!("appelé `my::function()`");
}

fn private_function() {
    println!("appelé `my::private_function()`");
}

pub fn indirect_access() {
    print!("appelé `my::indirect_access()`, qui\n> ");

    private_function();
}

Dans my/nested.rs :

pub fn function() {
    println!("appelé `my::nested::function()`");
}

#[allow(dead_code)]
fn private_function() {
    println!("appelé `my::nested::private_function()`");
}

Dans my/inaccessible.rs :

#[allow(dead_code)]
pub fn public_function() {
    println!("appelé `my::inaccessible::public_function()`");
}

Vérifions que tout fonctionne toujours comme avant :

$ rustc split.rs &&./split
appelé `my::function()`
appelé `function()`
appelé `my::indirect_access()`, qui
> appelé `my::private_function()`
appelé `my::nested::function()`

Sommaire

Félicitations ! Vous avez terminé le laboratoire Hiérarchie de fichiers. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.