The Rust Programming Language

Hello, World!

Maintenant que vous avez installé Rust, il est temps d’écrire votre premier programme Rust. C’est une tradition lorsqu’on apprend un nouveau langage d’écrire un petit programme qui affiche le texte Hello, world! à l’ecran, alors faisons de même !

Note : ce livre suppose une familiarité basique avec la ligne de commande. Rust n’impose aucune exigence particulière concernant votre éditeur, vos outils ou l’emplacement de votre code. Si vous préférez utiliser un IDE plutôt que la ligne de commande, n’hésitez pas à utiliser votre IDE préféré. De nombreux IDE offrent désormais un certain niveau de prise en charge de Rust ; consultez la documentation de l’IDE pour plus de détails. L’équipe Rust s’est concentrée sur l’activation d’une excellente prise en charge des IDE via rust-analyzer. Consultez l’annexe D pour plus de détails.

Mise en place du repertoire du projet

Vous commencerez par créer un repertoire pour stocker votre code Rust. Peu importe pour Rust ou se trouve votre code, mais pour les exercices et projets de ce livre, nous suggerons de créer un repertoire projects dans votre repertoire personnel et d’y conserver tous vos projets.

Ouvrez un terminal et entrez les commandes suivantes pour créer un repertoire projects et un repertoire pour le projet “Hello, world!” à l’intérieur du repertoire projects.

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

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Pour le CMD Windows, entrez ceci :

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Les bases 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 est d’utiliser un underscore pour les séparer. Par exemple, utilisez hello_world.rs plutot que helloworld.rs.

Maintenant, ouvrez le fichier main.rs que vous venez de créer et entrez le code de l’Encadre 1-1.

fn main() {
    println!("Hello, world!");
}

Sauvegardez le fichier et retournez à votre fenêtre de terminal dans le repertoire ~/projects/hello_world. Sous Linux ou macOS, entrez les commandes suivantes pour compiler et exécuter le fichier :

$ rustc main.rs
$ ./main
Hello, world!

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

> rustc main.rs
> .\main
Hello, world!

Quel que soit votre système d’exploitation, la chaîne Hello, world! devrait s’afficher dans le terminal. Si vous ne voyez pas cette sortie, reportez-vous à la partie « Résolution de problèmes » de la section Installation pour obtenir de l’aide.

Si Hello, world! s’est bien affiche, felicitations ! Vous avez officiellement écrit un programme Rust. Cela fait de vous un programmeur Rust – bienvenue !

L’anatomie d’un programme Rust

Examinons ce programme “Hello, world!” en détail. Voici le premier élément du puzzle :

fn main() {

}

Ces lignes définissent une fonction nommee main. La fonction main est speciale : c’est toujours le premier code qui s’exécute dans tout programme Rust exécutable. Ici, la première ligne déclaré une fonction nommee main qui n’a pas de paramètres et ne retourné rien. S’il y avait des paramètres, ils iraient à l’intérieur des parentheses (()).

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

Note : si vous souhaitez respecter un style standard dans vos projets Rust, vous pouvez utiliser un outil de formatage automatique appelé rustfmt pour formater votre code dans un style particulier (plus d’informations sur rustfmt dans l’annexe D). L’équipe Rust a inclus cet outil dans la distribution standard de Rust, tout comme rustc, il devrait donc déjà être installé sur votre ordinateur !

Le corps de la fonction main contient le code suivant :

#![allow(unused)]
fn main() {
println!("Hello, world!");
}

Cette ligne fait tout le travail dans ce petit programme : elle affiche du texte à l’ecran. Il y a trois détails importants a remarquer ici.

Premièrement, println! appelle une macro Rust. Si c’était un appel de fonction, cela s’écrirait println (sans le !). Les macros Rust sont un moyen d’écrire du code qui génère du code pour étendre la syntaxe de Rust, et nous en discuterons plus en détail au chapitre 20. Pour l’instant, vous devez simplement savoir que l’utilisation d’un ! signifie que vous appelez une macro plutôt qu’une fonction normale, et que les macros ne suivent pas toujours les mêmes règles que les fonctions.

Deuxiemement, vous voyez la chaîne "Hello, world!". Nous passons cette chaîne en argument a println!, et la chaîne est affichée à l’ecran.

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

Compilation et exécution

Vous venez d’exécuter un programme nouvellement crée, alors examinons chaque étape du processus.

Avant d’exécuter un programme Rust, vous devez le compiler en utilisant le compilateur Rust en entrant la commande rustc et en lui passant le nom de votre fichier source, comme ceci :

$ rustc main.rs

Si vous avez une experience en C ou C++, vous remarquerez que c’est similaire a gcc ou clang. Après une compilation reussie, Rust produit un exécutable binaire.

Sous Linux, macOS et PowerShell sur Windows, vous pouvez voir l’exécutable en entrant la commande ls dans votre terminal :

$ ls
main  main.rs

Sous Linux et macOS, vous verrez deux fichiers. Avec PowerShell sur Windows, vous verrez les mêmes trois fichiers que vous verriez en utilisant CMD. Avec CMD sur Windows, vous entreriez la commande suivante :

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

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 plateformes), et, sous Windows, un fichier contenant des informations de debogage avec l’extension .pdb. A partir de la, vous exécutez le fichier main ou main.exe, comme ceci :

$ ./main # or .\main on Windows

Si votre main.rs est votre programme “Hello, world!”, cette ligne affiche Hello, world! dans votre terminal.

Si vous etes plus familier avec un langage dynamique, comme Ruby, Python ou JavaScript, vous n’etes peut-etre pas habitue a compiler et exécuter un programme en deux étapes séparées. Rust est un langage compile à l’avance (ahead-of-time compiled), ce qui signifie que vous pouvez compiler un programme et donner l’exécutable a quelqu’un d’autre, qui pourra l’exécuter même sans avoir Rust installé. Si vous donnez a quelqu’un un fichier .rb, .py ou .js, cette personne doit avoir une implémentation de Ruby, Python ou JavaScript installée (respectivement). Mais dans ces langages, vous n’avez besoin que d’une seule commande pour compiler et exécuter votre programme. Tout est un compromis dans la conception des langages.

Compiler simplement avec rustc convient pour les programmes simples, mais a mesure que votre projet grandit, vous voudrez gérer toutes les options et faciliter le partage de votre code. Ensuite, nous vous présenterons l’outil Cargo, qui vous aidera a écrire des programmes Rust concrets.