Gestion de l'organisation Rust

Tout langage de programmation qui ne peut pas organiser le code sera difficile à maîtriser ; presque aucun produit logiciel n'est compilé à partir d'un seul fichier source.

Jusqu'à présent dans ce tutoriel, tous les programmes ont été écrits dans un seul fichier, principalement pour faciliter l'apprentissage de la syntaxe et des concepts de Rust.

Pour un projet, l'organisation du code est très importante.

Rust a trois concepts organisationnels importants : crate, paquet et module.

Crate

Un "crate" est un fichier programme binaire ou un fichier bibliothèque, et il existe dans un "paquet".

Un "crate" a une structure arborescente, et sa racine est le programme compilé à partir du fichier source que le compilateur compile lorsqu'il commence à s'exécuter.

Remarque : un "fichier programme binaire" n'est pas nécessairement un "fichier exécutable binaire" ; on peut seulement confirmer qu'il s'agit d'un fichier contenant du langage machine cible, et le format de fichier varie selon l'environnement de compilation.

Paquet

Lorsque nous utilisons Cargo pour exécuter la commande new afin de créer un projet Rust, un fichier Cargo.toml est créé dans le répertoire du projet. L'essence d'un projet est un paquet. Un paquet doit être géré par un fichier Cargo.toml, qui décrit les informations de base et les dépendances du paquet.

Un paquet peut contenir au plus un "crate" de bibliothèque, peut contenir un nombre quelconque de "crates" binaires, mais doit contenir au moins un "crate" (qu'il s'agisse d'une bibliothèque ou d'un "crate" binaire).

Après avoir créé un paquet avec la commande cargo new, un fichier source main.rs est généré dans le répertoire src. Cargo traite ce fichier comme la racine du crate binaire par défaut, et le crate binaire compilé aura le même nom que le paquet.

Module

Pour un projet logiciel, nous l'organisons souvent selon les conventions d'organisation du langage de programmation utilisé. La structure principale pour organiser les modules est souvent un arbre. L'unité principale pour organiser les modules fonctionnels en Java est la classe, tandis que la principale façon dont JavaScript organise les modules est par les fonctions.

Les unités organisationnelles de ces langages avancés peuvent être imbriquées couche par couche, tout comme la structure de répertoires d'un système de fichiers. L'unité organisationnelle en Rust est le module (Module).

mod nation {
    mod government {
        fn govern() {}
    }
    mod congress {
        fn legislate() {}
    }
    mod court {
        fn judicial() {}
    }
}

Ceci est un programme décrivant un pays gouverné par l'État de droit : la nation comprend le gouvernement, le congrès et le tribunal, qui ont respectivement une fonction exécutive, une fonction législative et une fonction judiciaire. Nous pouvons convertir cela en une structure arborescente :

nation
 ├── government
 │ └── govern
 ├── congress
 │ └── legislate
 └── court
   └── judicial

Dans un système de fichiers, la structure de répertoires utilise souvent des barres obliques dans les chaînes de chemin pour représenter la position des objets. Le séparateur de chemin en Rust est:: 。

Les chemins se divisent en chemins absolus et chemins relatifs. Les chemins absolus sont décrits en commençant par le mot-clé crate. Les chemins relatifs sont décrits en commençant par le mot-clé self ou super, ou par un identificateur. Par exemple :

crate::nation::government::govern();

est le chemin absolu décrivant la fonction govern. Le chemin relatif peut être exprimé comme :

nation::government::govern();

Maintenant, vous pouvez essayer de définir une structure de module similaire dans un programme source et d'utiliser des chemins dans la fonction main.

Si vous faites cela, vous constaterez certainement quelque chose d'anormal : le module government et les fonctions qu'il contient sont tous privés, et vous n'êtes pas autorisé à y accéder.


Autorisations d'accès

Rust a deux permissions d'accès simples : publique et privée.

Par défaut, si aucun modificateur n'est ajouté, l'autorisation d'accès des membres d'un module sera privée.

Si vous voulez utiliser l'autorisation publique, vous devez utiliser le mot-clé pub.

Pour les modules privés, ils ne sont accessibles que depuis des positions de même niveau ou de niveaux inférieurs ; ils ne sont pas accessibles depuis l'extérieur.

Exemple

mod nation {
    pub mod government {
        pub fn govern() {}
    }

    mod congress {
        pub fn legislate() {}
    }
   
    mod court {
        fn judicial() {
            super::congress::legislate();
        }
    }
}

fn main() {
    nation::government::govern();
}

Ce programme peut être compilé. Veuillez faire attention à la façon dont on accède à super dans le module court.

Si un struct est défini dans un module, en plus du fait que le struct lui-même est privé, ses champs sont aussi privés par défaut. Par conséquent, si vous souhaitez utiliser un struct et ses champs depuis un module, vous avez besoin de la déclaration pub :

Exemple

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("pêches"),
            }
        }
    }
}
pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("seigle");
    meal.toast = String::from("blé");
    println!("Je voudrais un toast au {} s'il vous plaît", meal.toast);
}
fn main() {
    eat_at_restaurant()
}

Sortie :

I'd like Wheat toast please

Les variantes d'énumération peuvent contenir des champs, mais elles n'ont pas de propriété similaire :

Exemple

mod SomeModule {
    pub enum Person {
        King {
            name: String
        },
        Queen
    }
}

fn main() {
    let person = SomeModule::Person::King{
        name: String::from("Blue")
    };
    match person {
        SomeModule::Person::King {name} => {
            println!("{}", name);
        }
        _ => {}
    }
}

Sortie :

Blue

Modules cachés

Les développeurs qui ont utilisé Java n'aiment souvent pas le bloc de classe le plus externe lorsqu'ils programment — son nom est exactement le même que le nom du fichier, car il représente le conteneur de fichier. Bien que ce soit fastidieux, nous devons l'écrire une fois pour souligner que "cette classe est la classe contenue dans le fichier".

Cependant, cela présente certains avantages : au moins, cela fait clairement prendre conscience aux développeurs de l'existence de l'encapsulation de classe, et cela peut clairement décrire les relations d'héritage de classes.

En Rust, les modules sont comme des wrappers de classe en Java, mais une fonction main peut être écrite tout au début d'un fichier. Comment expliquer cela ?

Le contenu de chaque fichier Rust est un module "caché".

Utilisons deux fichiers pour révéler cela :

fichier main.rs

// main.rs
mod second_module;

fn main() {
    println!("Ceci est le module principal.");
    println!("{}", second_module::message());
}

fichier second_module.rs

// second_module.rs
pub fn message() -> String {
    String::from("Ceci est le 2e module.")
}

Sortie :

This is the main module.
This is the 2nd module.

Mot-clé use

Le mot-clé use peut importer des identifiants de module dans la portée actuelle :

Exemple

mod nation {
    pub mod government {
        pub fn govern() {}
    }
}

use crate::nation::government::govern;

fn main() {
    govern();
}

Ce programme peut être compilé.

Comme le mot-clé use importe l'identifiant govern dans le module actuel, il peut être utilisé directement.

Cela résout le problème des chemins de modules locaux trop longs.

Bien sûr, dans certains cas, il y a deux noms identiques qui doivent aussi être importés. Nous pouvons utiliser le mot-clé as pour ajouter un alias à l'identifiant :

Exemple

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub fn govern() {}
}
   
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;

fn main() {
    nation_govern();
    govern();
}

Ici, il y a deux fonctions govern, l'une sous nation et l'autre sous government. Nous utilisons as pour donner à celle sous nation l'alias nation_govern. Les deux noms peuvent être utilisés simultanément.

Le mot-clé use peut être utilisé avec le mot-clé pub :

Exemple

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub use government::govern;
}

fn main() {
    nation::govern();
}

Référence à la bibliothèque standard

Documentation officielle de la bibliothèque standard Rust :https://doc.rust-lang.org/stable/std/all.html

Après avoir appris les concepts de ce chapitre, nous pouvons facilement importer des bibliothèques système pour développer des programmes commodément :

Exemple

use std::f64::consts::PI;

fn main() {
    println!("{}", (PI / 2.0).sin());
}

Sortie :

1

Tous les modules de la bibliothèque système sont importés par défaut, donc lorsque vous les utilisez, il vous suffit d'utiliser le mot-clé use pour simplifier les chemins pour une utilisation pratique.

Autres extensions