Rust est un excellent choix pour construire des applications complexes et fiables. L’une des compétences essentielles pour développer des applications Rust est de structurer vos projets de manière efficace, y compris en incorporant des paquets tiers.
Une organisation efficace des projets est cruciale pour le développement d’applications Rust. Des applications Rust bien structurées favorisent la collaboration et facilitent l’intégration d’applications tierces, réduisant ainsi de manière significative le temps et les efforts nécessaires au développement d’applications. Rust fournit un gestionnaire de paquets intégré et d’autres outils pour une organisation et une gestion efficaces du code.
Mise en place de projets Rust
La mise en place de projets Rust est facile une fois que vous avez installé Rust sur votre machine ; vous pouvez utiliser Cargo (le gestionnaire de paquets et le système de construction intégrés à Rust) pour créer et configurer un projet Rust. Il est similaire à d’autres gestionnaires de paquets comme npm pour Node.js et pip pour Python. Cargo gère les dépendances, compile le code et génère de la documentation, ce qui en fait un outil essentiel pour le développement de Rust.
Exécutez cette commande pour vérifier votre installation de Cargo :
cargo --version
La commande affiche la version de Cargo installée.
Vous pouvez créer un nouveau projet Rust avec la commande cargo new . Vous devrez spécifier le nom du projet.
cargo new my_project
La commande créera un nouveau répertoire dans le répertoire courant contenant les fichiers de base dont vous avez besoin pour votre projet Rust, y compris un fichier cargo.toml pour gérer les dépendances de votre projet.
L’espace de noms des paquets Rust
Les packages et les crates sont des composants essentiels de Rust. Les crates sont des bibliothèques ou des binaires que les développeurs de Rust peuvent utiliser et compiler pour un usage spécifique, et les packages sont une collection de crates. Les paquets contiennent généralement un crate qui contient le code réutilisable et un binaire qui fournit un CLI pour le crate de la bibliothèque.
Les crates doivent contenir le Cargo.toml fichier contenant des métadonnées sur le paquet, telles que son nom, sa version, ses dépendances et ses scripts de construction.
Les paquets Rust suivent une convention de nommage pour éviter les conflits de noms entre les paquets. Les noms de paquets doivent être globalement uniques, en minuscules, et ne contenir que des lettres, des chiffres et des traits d’union. Si le nom d’un paquet contient plusieurs mots, séparez-les par des traits d’union, par exemple hyper-serveur.
Vous pouvez accéder au code à l’intérieur d’un espace de noms d’un paquetage Rust à l’aide de l’option utiliser suivi des noms du paquet et de la caisse.
Voici un exemple d’importation d’un Rng fonction de a rand caisse :
use rand::Rng;
Vous pouvez créer plusieurs espaces de noms pour les paquets. Lorsque vous créez un dossier, vous créez un nouvel espace de noms auquel vous pouvez accéder à l’aide de la notation point pour spécifier le chemin d’accès à l’identifiant.
Dans Rust, il peut y avoir plusieurs espaces de noms pour les paquets. Lorsque vous créez un dossier, vous créez un nouvel espace de noms. Pour accéder au code d’un autre espace de noms, vous utilisez la notation point pour spécifier le chemin vers l’identifiant.
Voici un exemple d’accès à une fonction à partir d’un autre espace de noms :
// file in folder1 namespace
pub fn folder() -> u32 {
// some function body here
return 0;
}
// file in folder2 namespace
use folder1::folder;
pub fn directory() {
// accessing the folder function from the folder1 namespace
let folder_func = folder();
}
Le programme définit deux modules Rust dans des espaces de noms différents, dossier1 et dossier2 respectivement. Les dossier1 le module contient une fonction publique dossier qui renvoie une valeur entière non signée de 32 bits.
La fonction dossier2 importe le module dossier de la fonction dossier1 avec l’espace de noms utilisation permettant à l’utilisateur d’utiliser le mot-clé répertoire pour accéder à la fonction dossier de la fonction dossier1 module. Le module répertoire appelle la fonction dossier et la valeur de retour est assignée à la fonction folder_func variable.
Vous devrez mettre une majuscule au nom des identificateurs d’un paquet ou d’une caisse pour les exporter. Lorsque vous exportez un identifiant, vous le rendez accessible dans d’autres paquets qui utilisent le code.
Voici un exemple de fonction publique qui peut être exportée.
// function exported to other packages and crates
pub fn MyFunction() {
// some function body here
}
Vous devrez également utiliser la fonction pub mot-clé. En Rust, le mot-clé pub mot-clé est l’abréviation de public. Lorsqu’une fonction, une structure, une énumération, un type de données Rust ou un module est marqué par le mot-clé pub, il devient accessible en dehors de son module. L’élément est privé dans son module sans le mot-clé pub et n’est accessible qu’à l’intérieur de celui-ci.
Définir des modules pour contrôler la portée et la confidentialité
Vous pouvez utiliser des modules pour contrôler la portée et la confidentialité des programmes Rust. Les modules permettent d’organiser le code en unités logiques plus faciles à gérer et à maintenir.
Vous pouvez déclarer des modules à l’aide de la méthode mod suivi du nom du module et d’accolades. La définition d’un nouveau module crée un nouvel espace de noms pour son contenu, ce qui signifie que les fonctions, les structures et les autres éléments définis dans le module ne sont accessibles qu’à l’intérieur du module, à moins que vous ne les exportiez explicitement.
Les modules permettent d’éviter les conflits de noms et rendent le code plus intuitif à comprendre.
Voici la syntaxe d’un module simple :
mod my_module {
// module contents go here
}
Dans le module, vous pouvez définir des variables, des fonctions, des structures, des enums et d’autres types.
mod my_module {
fn add_numbers(a: i32, b: i32) -> i32 {
a + b
}
}
Vous pouvez utiliser la fonction pub pour exporter la fonction et y accéder dans d’autres parties du programme.
mod my_module {
pub fn add_numbers(a: i32, b: i32) -> i32 {
a + b
}
}
Vous pouvez maintenant appeler la fonction add_numbers à partir d’autres parties de votre programme.
Vous pouvez également contrôler la confidentialité des modules à l’aide de la fonction pub mot-clé sur les définitions de modules.
pub mod my_module {
pub fn add_numbers(a: i32, b: i32) -> i32 {
a + b
}
}
Désormais, le mot-clé mon_module est public et vous pouvez y accéder à partir d’autres modules.
Si vous devez rendre un module ou un élément accessible à un module spécifique ou à un ensemble de modules, vous pouvez utiliser la fonction pub(crate) mot-clé. Le mot-clé pub(crate) rend l’élément accessible depuis les modules du même casier, mais pas depuis les modules d’autres casiers.
mod my_module {
pub struct MyStruct {
pub(crate) some_field: u32,
}
}
Vous pouvez maintenant accéder à l’élément spécifique (dans ce cas, l’élément some_field champ du MyStruct struct) dans d’autres parties de votre programme.
fn main() {
let my_struct = my_module::MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}
La fonction ma_struct est une instance de la classe MyStruct struct. La variable accède à la structure avec le séparateur de chemin (: :). La variable principal imprime le résultat de la fonction some_field champ de la structure avec l’élément println ! macro.
Le modèle de propriété de Rust garantit la sécurité de la mémoire
L’organisation du code Rust est un moyen de s’assurer que votre code est facile à maintenir et à supporter dans le temps. Il est plus facile de s’attaquer aux bogues et d’assurer la sécurité dans un code bien organisé qui suit les règles et les conventions de la communauté Rust.
Par défaut, Rust s’assure que les programmes sont sûrs en mémoire grâce à un modèle de propriété intégré. Le modèle de propriété garantit la sécurité de la mémoire en s’assurant que les variables en mémoire ont un propriétaire unique. Le modèle de propriété permet d’éviter les traces de données et de nombreux types d’erreurs de mémoire.
