Les premiers pas

Maintenant que vous avez installé Rust, il est temps d'écrire votre premier programme Rust. Il est de tradition, lors de l'apprentissage d'un nouveau langage de programmation, d'écrire un petit programme affichant le texte Bonjour le monde! à l'écran, nous allons donc faire la même chose ici !

Créer un répertoire de projet

Vous commencerez par créer un répertoire pour entreposer votre code Rust. L'emplacement de votre code n'a pas d'importance pour Rust, mais il est recommandé de créer un répertoire de projets dans votre répertoire personnel et d'y conserver tous vos projets.

Ouvrez un terminal et saisissez les commandes suivantes pour créer un répertoire de projets et un répertoire pour le projet «Bonjour le monde» dans le répertoire de projets.

Pour Linux, macOS et PowerShell sur Windows, saisissez ceci :

Pour le CMD de Windows, entrez ceci :

Écriture et exécution d'un programme Rust

Ensuite, créez un nouveau fichier source et appelez-le main.rs. Les fichiers Rust se terminent toujours par l'extension .rs. Si vous utilisez plusieurs mots dans votre nom de fichier, la convention consiste à utiliser un trait de soulignement pour les séparer. Par exemple, utilisez hello_world.rs plutôt que helloworld.rs.

Ouvrez maintenant le fichier main.rs que vous venez de créer et saisissez le code dans la liste suivante :

Enregistrez le fichier et revenez à votre fenêtre de terminal dans le répertoire ~/projects/hello_world. Sous Linux ou macOS, saisissez les commandes suivantes pour compiler et exécuter le fichier :

Sous Windows, entrez la commande .\main.exe au lieu de ./main :

Quel que soit votre système d'exploitation, la chaîne de caractères Bonjour le monde doit s'afficher sur le terminal. Si vous ne voyez pas cette sortie, reportez-vous à la partie «Dépannage» de la page Installation pour savoir comment obtenir de l'aide.

Si Bonjour le monde s'affiche, félicitations ! Vous avez officiellement écrit un programme Rust.

Anatomie d'un programme Rust

Examinons en détail ce programme «Bonjour le monde». Voici la première pièce du casse-tête :

Ces lignes définissent une fonction nommée main. La fonction main est spéciale : c'est toujours le premier code s'exécutant dans chaque programme Rust exécutable. Ici, la première ligne déclare une fonction nommée main qui n'a pas de paramètres et ne renvoie rien. S'il y avait des paramètres, ils seraient placés entre parenthèses ().

Le corps de la fonction est entouré de {}. Rust nécessite des accolades autour de tous les corps de fonction. Il est de bon ton de placer l'accolade ouvrante sur la même ligne que la déclaration de fonction, en ajoutant un espace entre les deux.

Remarque : si vous souhaitez vous en tenir à un style standard dans tous les projets Rust, vous pouvez utiliser un outil de formatage automatique appelé rustfmt pour formater votre code dans un style particulier. L'équipe Rust a inclus cet outil dans la distribution Rust standard, comme rustc, il devrait donc déjà être installé sur votre ordinateur !

Le corps de la fonction main contient le code suivant :

Cette ligne fait tout le travail dans ce petit programme : elle affiche le texte à l'écran. Il y a quatre détails importants à noter ici.

Tout d'abord, le style Rust consiste à indenter avec quatre espaces, pas une tabulation.

Deuxièmement, println! appelle une macro Rust. Si elle avait appelé une fonction à la place, elle aurait été saisie comme println (sans le !). Pour l'instant, vous devez juste savoir qu'utiliser un ! signifie que vous appelez une macro au lieu d'une fonction normale et que les macros ne suivent pas toujours les mêmes règles que les fonctions.

Troisièmement, vous voyez la chaîne de caractères "Bonjour le monde!". Nous passons cette chaîne de caractères comme paramètres à println!, et la chaîne de caractères est affichée à l'écran.

Quatrièmement, nous terminons la ligne par un point-virgule (;), indiquant que cette expression est terminée et que la suivante est prête à commencer. La plupart des lignes de code Rust se terminent par un point-virgule.

La compilation et l'exécution sont des étapes distinctes

Vous venez d'exécuter un programme nouvellement créé, examinons donc chaque étape du processus.

Avant d'exécuter un programme Rust, vous devez le compiler à l'aide du compilateur Rust en saisissant la commande rustc et en lui transmettant le nom de votre fichier source, comme ceci :

Si vous avez des connaissances en C ou C++, vous remarquerez que cela ressemble à gcc ou clang. Une fois la compilation terminée, Rust génère un exécutable binaire.

Sur Linux, macOS et PowerShell sous Windows, vous pouvez voir l'exécutable en saisissant la commande ls dans votre interpréteur de commande :

Sous Linux et macOS, vous verrez deux fichiers. Avec PowerShell sous Windows, vous verrez les trois mêmes fichiers que ceux que vous verriez avec CMD. Avec CMD sous Windows, vous saisiriez les éléments suivants :

Cela montre le fichier de code source avec l'extension .rs, le fichier exécutable (main.exe sous Windows, mais main sur toutes les autres plates-formes) et, lorsque vous utilisez Windows, un fichier contenant des informations de débogage avec l'extension .pdb. À partir de là, vous exécutez le fichier main ou main.exe, comme ceci :

Si votre main.rs est votre programme «Bonjour le monde», cette ligne affiche Bonjour le monde sur votre terminal.

Si vous êtes plus familier avec un langage dynamique, tel que Ruby, Python ou JavaScript, vous n'êtes peut-être pas habitué à compiler et à exécuter un programme en étapes séparées. Rust est un langage compilé à l'avance, ce qui signifie que vous pouvez compiler un programme et donner l'exécutable à quelqu'un d'autre, et qu'il peut l'exécuter même sans avoir installé Rust. Si vous donnez à quelqu'un un fichier .rb, .py ou .js, il doit avoir une implémentation Ruby, Python ou JavaScript installée (respectivement). Mais dans ces langages de programmation, vous n'avez besoin que d'une seule commande pour compiler et exécuter votre programme. Tout est un compromis dans la conception du langage.

La simple compilation avec rustc convient aux programmes simples, mais à mesure que votre projet se développe, vous souhaiterez gérer toutes les options et faciliter le partage de votre code. Ensuite, il propose l'outil Cargo, vous aidant à écrire des programmes Rust réels.

Cargo

Cargo est le système de construction et le gestionnaire de paquets de Rust. La plupart des Rustaceans utilisent cet outil pour gérer leurs projets Rust car Cargo gère de nombreuses tâches pour vous, comme la construction de votre code, le téléchargement des bibliothèques dont dépend votre code et la construction de ces bibliothèques. (Nous appelons les bibliothèques dont votre code a besoin des dépendances.)

Les programmes Rust les plus simples, comme celui que nous avons écrit jusqu'à présent, n'ont aucune dépendance. Si nous avions construit le projet «Bonjour le monde» avec Cargo, il n'utiliserait que la partie de Cargo gérant la construction de votre code. Au fur et à mesure que vous écrivez des programmes Rust plus complexes, vous ajouterez des dépendances, et si vous démarrez un projet en utilisant Cargo, l'ajout de dépendances sera beaucoup plus facile à faire.

Comme la grande majorité des projets Rust utilisent Cargo, le reste des pages suppose que vous utilisez également Cargo. Cargo est installé avec Rust si vous avez utilisé les installateurs officiels décrits dans la page «Installation». Si vous avez installé Rust par un autre moyen, vérifiez si Cargo est installé en saisissant ce qui suit dans votre terminal :

Si vous voyez un numéro de version, c'est que vous l'avez ! Si vous voyez une erreur, telle que command not found, consultez la documentation de votre méthode d'installation pour déterminer comment installer Cargo séparément.

Création d'un projet avec Cargo

Créons un nouveau projet à l'aide de Cargo et voyons en quoi il diffère de notre projet original «Bonjour le monde». Revenez à votre répertoire de projets (ou à l'endroit où vous avez décidé d'entreposer votre code). Ensuite, sur n'importe quel système d'exploitation, exécutez la commande suivante :

La première commande crée un nouveau répertoire et un projet appelé hello_cargo. Nous avons nommé notre projet hello_cargo, et Cargo crée ses fichiers dans un répertoire du même nom.

Allez dans le répertoire hello_cargo et listez les fichiers. Vous verrez que Cargo a généré deux fichiers et un répertoire pour nous : un fichier Cargo.toml et un répertoire src avec un fichier main.rs à l'intérieur.

Il a également initialisé un nouveau dépôt Git avec un fichier .gitignore. Les fichiers Git ne seront pas générés si vous exécutez cargo new dans un dépôt Git existant ; vous pouvez remplacer ce comportement en utilisant cargo new --vcs=git.

Remarque : Git est un système de contrôle de version courant. Vous pouvez modifier cargo new pour utiliser un système de contrôle de version différent ou aucun système de contrôle de version en utilisant l'indicateur --vcs. Exécutez cargo new --help pour voir les options disponibles.

Ouvrez Cargo.toml dans l'éditeur de texte de votre choix. Il devrait ressembler au code suivant :

Ce fichier est au format TOML (Tom's Obvious, Minimal Language), étant le format de configuration de Cargo.

La première ligne, [package], est un entête de section indiquant que les instructions suivantes configurent un paquet. Au fur et à mesure que nous ajouterons plus d'informations à ce fichier, nous ajouterons d'autres sections.

Les trois lignes suivantes définissent les informations de configuration dont Cargo a besoin pour compiler votre programme : le nom, la version et l'édition de Rust à utiliser.

La dernière ligne, [dependencies], est le début d'une section dans laquelle vous pouvez lister les dépendances de votre projet. Dans Rust, les paquets de code sont appelés crates. Nous n'aurons pas besoin d'autres crates pour ce projet, nous utiliserons donc cette section de dépendances.

Ouvrez maintenant src/main.rs et jetez un oeil :

Cargo a généré pour vous un programme «Bonjour le monde», tout comme celui que nous avons écrit dans le code précédent ! Jusqu'à présent, les différences entre notre projet et le projet généré par Cargo sont que Cargo a placé le code dans le répertoire src et que nous avons un fichier de configuration Cargo.toml dans le répertoire supérieur.

Cargo s'attend à ce que vos fichiers sources se trouvent dans le répertoire src. Le répertoire de projet de niveau supérieur est uniquement destiné aux fichiers README, aux informations de licence, aux fichiers de configuration et à tout ce qui n'est pas lié à votre code. L'utilisation de Cargo vous aide à organiser vos projets. Il y a une place pour chaque chose, et chaque chose est à sa place.

Si vous avez démarré un projet n'utilisant pas Cargo, comme nous l'avons fait avec le projet «Bonjour le monde», vous pouvez le convertir en un projet utilisant Cargo. Déplacez le code du projet dans le répertoire src et créez un fichier Cargo.toml approprié. Un moyen simple d'obtenir ce fichier Cargo.toml est d'exécuter cargo init, le créant automatiquement pour vous.

Création et exécution d'un projet Cargo

Voyons maintenant ce qui est différent lorsque nous créons et exécutons le programme «Bonjour le monde» avec Cargo ! À partir de votre répertoire hello_cargo, créez votre projet en saisissant la commande suivante :

Cette commande crée un fichier exécutable dans target/debug/hello_cargo (ou target\debug\hello_cargo.exe sous Windows) plutôt que dans votre répertoire actuel. Étant donné que la version par défaut est une version de débogage, Cargo place le binaire dans un répertoire nommé debug. Vous pouvez exécuter l'exécutable avec cette commande :

Si tout se passe bien, Bonjour le monde devrait s'afficher sur le terminal. L'exécution de cargo build pour la première fois entraîne également la création par Cargo d'un nouveau fichier au niveau supérieur : Cargo.lock. Ce fichier conserve la trace des versions exactes des dépendances de votre projet. Ce projet n'a pas de dépendances, le fichier est donc un peu clairsemé. Vous n'aurez jamais besoin de modifier ce fichier manuellement ; Cargo gère son contenu pour vous.

Nous venons de créer un projet avec cargo build et de l'exécuter avec ./target/debug/hello_cargo, mais nous pouvons également utiliser cargo run pour compiler le code, puis exécuter l'exécutable résultant en une seule commande :

Utiliser cargo run est plus pratique que de devoir se rappeler d'exécuter cargo build puis d'utiliser le chemin complet vers le binaire, c'est pourquoi la plupart des développeurs utilisent cargo run.

Notez que cette fois, nous n'avons pas vu de sortie indiquant que Cargo compilait hello_cargo. Cargo a compris que les fichiers n'avaient pas changé, il n'a donc pas reconstruit mais a simplement exécuté le binaire. Si vous aviez modifié votre code source, Cargo aurait reconstruit le projet avant de l'exécuter, et vous auriez vu cette sortie :

Cargo fournit également une commande appelée cargo check. Cette commande vérifie rapidement votre code pour s'assurer qu'il compile mais ne produit pas d'exécutable :

Pourquoi ne voudriez-vous pas d'un exécutable ? Souvent, cargo check est beaucoup plus rapide que cargo build car il saute l'étape de production d'un exécutable. Si vous vérifiez continuellement votre travail pendant l'écriture du code, l'utilisation de cargo check accélérera le processus d'avertissement si votre projet est toujours en cours de compilation ! De ce fait, de nombreux Rustaceans exécutent cargo check périodiquement pendant qu'ils écrivent leur programme pour s'assurer qu'il compile. Ensuite, ils exécutent cargo build lorsqu'ils sont prêts à utiliser l'exécutable.

Récapitulons ce que nous avons appris jusqu'à présent sur Cargo :

• Nous pouvons créer un projet en utilisant cargo new.
• Nous pouvons construire un projet en utilisant cargo build.
• Nous pouvons construire et exécuter un projet en une seule étape en utilisant cargo run.
• Nous pouvons construire un projet sans produire de binaire pour vérifier les erreurs en utilisant cargo check.
• Au lieu d'enregistrer le résultat de la construction dans le même répertoire que notre code, Cargo le stocke dans le répertoire target/debug.

Un autre avantage de l'utilisation de Cargo est que les commandes sont les mêmes quel que soit le système d'exploitation sur lequel vous travaillez. Ainsi, à ce stade, nous ne fournirons plus d'instructions spécifiques pour Linux et macOS par rapport à Windows.

Création pour la publication

Lorsque votre projet est enfin prêt pour la publication, vous pouvez utiliser cargo build --release pour le compiler avec des optimisations. Cette commande créera un exécutable dans target/release au lieu de target/debug. Les optimisations accélèrent l'exécution de votre code Rust, mais leur activation allonge le temps de compilation de votre programme. C'est pourquoi il existe deux profils différents : l'un pour le développement, lorsque vous souhaitez reconstruire rapidement et souvent, et l'autre pour construire le programme final que vous donnerez à un utilisateur n'étant pas reconstruit à plusieurs reprises et s'exécutant aussi vite que possible. Si vous évaluez le temps d'exécution de votre code, assurez-vous d'exécuter cargo build --release et de le comparer avec l'exécutable dans target/release.

Cargo comme convention

Avec des projets simples, Cargo n'offre pas beaucoup de valeur ajoutée par rapport à l'utilisation de rustc, mais il fera ses preuves à mesure que vos programmes deviendront plus complexes. Une fois que les programmes se développent sur plusieurs fichiers ou ont besoin d'une dépendance, il est beaucoup plus facile de laisser Cargo coordonner la construction.

Même si le projet hello_cargo est simple, il utilise désormais une grande partie des outils réels que vous utiliserez dans le reste de votre carrière Rust. En fait, pour travailler sur des projets existants, vous pouvez utiliser les commandes suivantes pour extraire le code à l'aide de Git, accéder au répertoire de ce projet et compiler :