Organisation des projets Rust avec des packages, des chemins et des modules

Rust est un excellent choix pour créer des applications complexes et fiables. L'une des compétences essentielles pour développer des applications Rust consiste à structurer efficacement vos projets, notamment en intégrant des packages tiers.

Une organisation de projet efficace est cruciale pour le développement d'applications Rust. Des applications Rust bien structurées améliorent la collaboration et facilitent les intégrations d'applications tierces, réduisant considérablement le temps et les efforts nécessaires au développement d'applications. Rust fournit un gestionnaire de packages intégré et d'autres outils pour une organisation et une gestion efficaces du code.

Configuration de projets Rust

La configuration de projets Rust est facile une fois que vous avez installé Rust sur votre machine; vous pouvez utiliser Cargo (le gestionnaire de packages et le système de construction intégrés de 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 Cargo :

cargaison --version

La commande affiche la version Cargo installée.

Vous pouvez créer un nouveau projet Rust avec le cargaison nouveau commande. Vous devrez spécifier le nom du projet.

cargaison nouveau mon_projet

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 cargo.toml fichier pour gérer les dépendances de votre projet.

L'espace de noms du paquet Rust

Les colis et les caisses sont des composants essentiels de Rust. Les caisses sont des bibliothèques ou des binaires que les développeurs Rust peuvent utiliser et compiler pour une utilisation spécifique, et les packages sont une collection de caisses. Les packages contiennent généralement une caisse qui contient le code réutilisable et un binaire qui fournit une CLI pour la caisse de la bibliothèque.

Les caisses doivent contenir Cargaison.toml fichier contenant des métadonnées sur le package, telles que son nom, sa version, ses dépendances et ses scripts de construction.

Les packages Rust suivent une convention de nommage pour éviter les conflits de nommage entre les packages. Les noms de package doivent être uniques au monde, en minuscules et ne contenir que des lettres, des chiffres et des tirets. Si un nom de package contient plusieurs mots, séparez-les par des traits d'union, par ex. hyper-serveur.

Vous pouvez accéder au code dans un espace de noms de package Rust avec le utiliser mot-clé suivi du nom du colis et de la caisse.

Voici un exemple d'importation d'un Rng fonction d'un rand Caisse:

utiliser rand:: Rng;

Vous pouvez créer plusieurs espaces de noms pour les packages. Lorsque vous créez un dossier, vous créez un nouvel espace de noms auquel vous pouvez accéder avec la notation par points pour spécifier le chemin d'accès à l'identifiant.

Dans Rust, il peut y avoir plusieurs espaces de noms pour les packages. Lorsque vous créez un dossier, vous créez un nouvel espace de noms. Pour accéder au code à partir d'un autre espace de noms, vous utilisez une notation par points pour spécifier le chemin d'accès à l'identifiant.

Voici un exemple d'accès à une fonction à partir d'un espace de noms différent :

// fichier dans l'espace de noms dossier1
pubfndossier() -> u32 {
// un corps de fonction ici
retour0;
}
// fichier dans l'espace de noms dossier2
utiliser dossier1:: dossier;
pubfnannuaire() {
// accéder à la fonction de dossier à partir de l'espace de noms dossier1
laisser dossier_fonc = dossier();
}

Le programme définit deux modules Rust dans des espaces de noms différents, dossier1 et dossier2 respectivement. Le dossier1 le module contient une fonction publique dossier qui renvoie une valeur entière non signée 32 bits.

Le dossier2 le module importe le dossier fonction de la dossier1 espace de noms avec le utiliser mot-clé, permettant au annuaire fonction pour accéder à la dossier fonction de la dossier1 module. Le annuaire la fonction appelle le dossier fonction, et la valeur de retour est assignée à la dossier_fonc variable.

Vous devrez mettre en majuscule le nom des identifiants d'un paquet ou d'une caisse pour les exporter. Lorsque vous exportez un identifiant, vous le rendez accessible dans d'autres packages qui utilisent le code.

Voici un exemple de fonction publique qui peut être exportée.

// fonction exportée vers d'autres packages et crates
pubfnMaFonction() {
// un corps de fonction ici
}

Vous devrez également utiliser le pub mot-clé. A Rust, le pub le mot-clé est l'abréviation de public. Lorsqu'une fonction, une structure, une énumération, tout type de données Rust ou module est marqué avec le mot-clé pub, il devient accessible en dehors de son module. L'élément est privé à son module sans le mot-clé pub et n'est accessible qu'à partir 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é dans les programmes Rust. Les modules vous permettent d'organiser le code en unités logiques plus faciles à gérer et à maintenir.

Vous pouvez déclarer des modules avec le mode mot-clé suivi du nom du module et des 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 ou les autres éléments définis dans le module ne sont accessibles que dans le module sauf si vous exportez explicitement eux.

Les modules aident à prévenir les conflits de noms, rendant le code plus intuitif à comprendre.

Voici la syntaxe d'un module simple :

mode mon_module {
// le contenu du module va ici
}

Dans le module, vous pouvez définir des variables, des fonctions, des structures, des énumérations et d'autres types.

mode mon_module {
fnadd_numbers(un: i32, b: i32) -> i32 {
 un + b
 }
}

Vous pouvez utiliser le pub mot-clé pour exporter la fonction et accéder à la fonction dans d'autres parties du programme.

mode mon_module {
pubfnadd_numbers(un: i32, b: i32) -> i32 {
 un + b
 }
}

Maintenant, vous pouvez appeler le add_numbers fonction d'autres parties de votre programme.

Vous pouvez également contrôler la confidentialité des modules avec le pub mot-clé sur les définitions de module.

pubmode mon_module {
pubfnadd_numbers(un: i32, b: i32) -> i32 {
 un + b
 }
}

Maintenant le mon_module module est public et vous pouvez accéder au module à partir d'autres modules.

Si vous devez rendre un module ou un élément accessible à un module ou à un ensemble de modules spécifique, vous pouvez utiliser la pub (caisse) mot-clé. Le pub (caisse) mot-clé rend l'élément accessible à partir de modules dans le même crate mais pas à partir de modules dans d'autres crates.

mode mon_module {
pubstructureMaStructure {
pub(Caisse) un_champ: u32,
 }
}

Vous pouvez maintenant accéder à l'élément spécifique (dans ce cas, le un_champ domaine de la MaStructure struct) dans d'autres parties de votre programme.

fnprincipal() {
laisser my_struct = my_module:: MyStruct { some_field: 42 };
imprimez !("{}", my_struct.some_field);
}

Le ma_struct variable est une instance de MaStructure structure. La variable accède à la structure avec le séparateur de chemin (::). Le principal la fonction imprime le un_champ champ de la structure avec le imprimez ! 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 à prendre en charge au fil du 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 conventions de la communauté Rust.

Par défaut, Rust garantit que les programmes sont sécurisés en mémoire avec un modèle de propriété intégré. Le modèle de propriété assure la sécurité de la mémoire en garantissant que les variables en mémoire ont un propriétaire unique. Le modèle de propriété empêche les traces de données et de nombreux types d'erreurs de mémoire.