Introduction
Les programmes Rust sont généralement organisés et exécutés avec Cargo, l’outil de gestion de projets et de compilation de Rust. Dans cet atelier, vous allez terminer un petit projet Cargo dans un terminal Linux. Aucune expérience préalable du terminal, d’un éditeur ou de Rust n’est nécessaire.
Vous apprendrez à accéder à un dossier de projet, à modifier un fichier source Rust avec nano, à demander à Cargo de vérifier le code et à exécuter le programme terminé. L’atelier vérifie à la fois votre code source et la sortie exacte du programme.
Accéder au projet et modifier son code source
Dans cette étape, vous allez localiser le projet préparé et effectuer votre première petite modification Rust avec nano.
Le terminal est la zone de texte dans laquelle vous saisissez des commandes. Une commande est une instruction destinée à l’ordinateur. Cliquez d’abord dans le terminal pour lui donner le focus clavier, saisissez la commande suivante, puis appuyez sur Entrée :
pwd
pwd signifie print working directory (« afficher le répertoire de travail »). Un répertoire est un autre nom pour un dossier. La sortie affiche le dossier dans lequel vous vous trouvez actuellement, généralement /home/labex.
Ensuite, affichez les éléments de ce dossier :
ls
ls signifie list (« lister »). Vous devriez voir un dossier nommé project.
Utilisez cd, qui signifie change directory (« changer de répertoire »), pour accéder au projet Rust préparé. Le chemin commence par / : il s’agit donc d’un chemin absolu, qui indique l’emplacement à partir de la racine du système de fichiers, et non à partir du répertoire actuel.
cd /home/labex/project/hello-rust
En général, le terminal n’affiche rien lorsque cd réussit. Affichez le contenu du projet :
ls
Vous devriez voir Cargo.toml et src. Cargo lit Cargo.toml pour connaître le nom du paquet, sa version, l’édition de Rust et ses dépendances. Le répertoire src contient le code source Rust ; ce programme commence dans src/main.rs.
Ouvrez le fichier source dans nano, un éditeur de texte en terminal adapté aux débutants :
nano src/main.rs
src/main.rs est un chemin relatif. Comme il ne commence pas par /, le terminal le recherche dans votre répertoire actuel, /home/labex/project/hello-rust. C’est pourquoi il est important d’accéder d’abord au projet avec cd.
Le fichier s’affiche dans le terminal. Utilisez les touches fléchées pour déplacer le curseur. Modifiez uniquement les cinq caractères de soulignement afin que la ligne devienne :
println!("Hello from LabEx!");
En bas de nano, le symbole ^ représente la touche Ctrl. Enregistrez le fichier avec Ctrl+O (maintenez Ctrl enfoncée et appuyez sur O), puis appuyez sur Entrée pour confirmer le nom du fichier. Quittez avec Ctrl+X.
Rouvrez le même fichier pour vérifier que l’enregistrement a bien écrit la modification sur le disque :
nano src/main.rs
Vérifiez que la ligne contient Hello from LabEx!. Vous n’avez pas besoin de la modifier à nouveau ; quittez donc avec Ctrl+X. Rouvrir un fichier enregistré est une vérification utile lorsque vous n’êtes pas certain qu’une modification effectuée dans un éditeur a bien été conservée.
Affichez le fichier enregistré sans rouvrir l’éditeur :
cat src/main.rs
cat affiche le contenu d’un fichier dans le terminal. Contrairement à nano, il affiche uniquement le fichier et ne fournit pas d’écran d’édition. Vérifiez que vous voyez Hello from LabEx! et qu’il n’y a aucun caractère de soulignement dans le message.
Ajouter un message et vérifier le code
Dans cette étape, vous allez comprendre la structure du petit programme, ajouter une ligne et demander à Cargo de rechercher les erreurs.
Votre terminal devrait toujours se trouver dans /home/labex/project/hello-rust. En cas de doute, pwd affiche le répertoire actuel. Ouvrez à nouveau le fichier source :
nano src/main.rs
Le programme contient plusieurs éléments importants de Rust :
fn main()définit la fonction principale, qui constitue le point de départ du programme.- Les accolades ouvrante et fermante,
{et}, délimitent les instructions de la fonction. println!affiche une ligne de texte. Le caractère!indique queprintln!est une macro Rust.- Le texte placé entre guillemets doubles est une chaîne littérale.
- Le point-virgule
;termine cette instruction.
Placez le curseur à la fin de la ligne println! existante, appuyez sur Entrée, puis ajoutez cette deuxième instruction avant l’accolade fermante :
println!("I am learning Rust with Cargo.");
Le fichier complet doit maintenant être le suivant :
fn main() {
println!("Hello from LabEx!");
println!("I am learning Rust with Cargo.");
}
Enregistrez avec Ctrl+O, appuyez sur Entrée, puis quittez avec Ctrl+X.
Demandez maintenant à Cargo de vérifier si le paquet peut être compilé :
cargo check
cargo check analyse le code et signale les erreurs sans produire le programme final exécutable. La première vérification peut prendre un peu de temps. En cas de réussite, le résultat se termine par une ligne contenant Finished.
Si Cargo signale une erreur, comparez votre fichier avec l’exemple complet. Faites particulièrement attention aux guillemets, aux parenthèses, aux points-virgules et aux accolades. Utilisez nano src/main.rs pour corriger le fichier, enregistrez-le, puis exécutez à nouveau cargo check.
Exécuter le programme avec Cargo
Dans cette étape, vous allez compiler et exécuter votre programme Rust vérifié.
Exécutez la commande suivante depuis /home/labex/project/hello-rust :
cargo run
cargo run effectue deux opérations liées : il compile le paquet pour créer un programme exécutable, puis il démarre ce programme. Cargo peut afficher quelques lignes concernant l’état de la compilation avant votre propre sortie.
Vers la fin, vous devriez voir ces deux lignes :
Hello from LabEx!
I am learning Rust with Cargo.
Exécutez une nouvelle fois le programme en masquant les messages d’état de Cargo :
cargo run --quiet
L’option --quiet réduit la sortie produite par Cargo ; seules les deux lignes de votre programme devraient donc s’afficher. Vous avez maintenant terminé le fonctionnement de base de Cargo : modifier, vérifier et exécuter.
Résumé
Vous avez utilisé un terminal Linux, modifié et enregistré du code Rust avec nano, identifié la fonction principale et la macro println!, vérifié un paquet Cargo et exécuté celui-ci. Le cycle modification-vérification-exécution que vous avez pratiqué constitue la base des projets Rust suivants.
