Débuter avec Rust

Installons Rust sur votre machine et construisons votre premier programme. Si vous préférez ne rien installer pour l’instant, vous pouvez suivre dans le Rust Playground (un environnement pour exécuter Rust dans le navigateur) et revenir à cette page plus tard.

Étape 1 : installer Rust avec rustup

La façon officielle d’installer Rust, c’est un outil appelé rustup. Il installe le compilateur Rust et l’outil de build cargo, puis garde le tout à jour.

Rendez-vous sur rustup.rs et suivez les instructions pour votre système :

• Windows : téléchargez et lancez rustup-init.exe, puis acceptez les options par défaut.

• macOS / Linux : collez ceci dans votre terminal :

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Note

Sous Windows, Rust a besoin des outils de build C++. Si l’installateur vous le propose, laissez-le installer les « Visual Studio C++ Build Tools » : Rust s’en sert pour lier (link) vos programmes.

Étape 2 : vérifier que tout fonctionne

Fermez puis rouvrez votre terminal, et lancez :

rustc --version
cargo --version

Vous devriez voir des numéros de version comme rustc 1.xx.0. Si c’est le cas, tout est prêt.

• rustc est le compilateur Rust (il transforme votre code en programme).
• cargo est l’outil tout-en-un de Rust pour compiler, exécuter, tester et gérer vos projets. Vous utiliserez cargo pour presque tout.

Étape 3 : créer votre premier projet

Plutôt que de créer les fichiers à la main, laissez cargo préparer un projet pour vous :

cargo new hello_rust
cd hello_rust

Cela crée un dossier hello_rust avec tout ce dont un projet Rust a besoin :

hello_rust/
├── Cargo.toml      # réglages du projet et dépendances
└── src/
    └── main.rs     # votre code va ici

• Cargo.toml décrit votre projet (son nom, sa version et les bibliothèques qu’il utilise).
• src/main.rs est le fichier de départ. cargo y met même un « Hello World » pour vous.

Étape 4 : le lancer

Depuis le dossier du projet, lancez :

cargo run

Vous verrez cargo compiler le projet, puis afficher :

Hello, world!

C’est tout : vous venez de compiler et d’exécuter un programme Rust. (Le message est en anglais parce que c’est le programme d’exemple que cargo new génère.)

Comprendre le code

Ouvrez src/main.rs et vous trouverez :

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

• fn main() { ... } définit la fonction principale : tout programme Rust commence son exécution ici.
• println!("...") affiche une ligne de texte à l’écran.

Essayez de changer le message et relancez cargo run :

fn main() {
    println!("Bonjour depuis mon premier programme Rust !");
}

Sortie :

Bonjour depuis mon premier programme Rust !

▶ Essayez par vous-même

cargo run ou cargo build ?

Deux commandes que vous utiliserez sans arrêt :

Commande	Ce qu’elle fait
cargo run	Compile et exécute votre programme (idéal pendant le développement)
cargo build	Compile seulement : le programme se retrouve dans target/debug/
cargo build --release	Compile une version optimisée, plus rapide, pour la distribuer

Quand ça ne marche pas : lire les erreurs du compilateur

Vous verrez des erreurs de compilation, tous les jours, même après des années de Rust. Ce n’est pas le signe que vous êtes mauvais. C’est le compilateur qui fait son travail. Provoquons-en une exprès, pour qu’elle fasse moins peur la première fois.

Supprimez le ! de println! dans src/main.rs :

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

Lancez cargo run et vous obtiendrez :

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Hello, world!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Hello, world!");
  |            +

Les messages de rustc sont toujours en anglais. Lisez-le de haut en bas :

1. La première ligne dit ce qui ne va pas : Rust attendait une fonction (expected function), mais println est une macro (vous verrez ce que cela veut dire à la page suivante).
2. --> src/main.rs:2:5 indique où : le fichier src/main.rs, ligne 2, colonne 5.
3. Les marques ^^^^^^^ pointent exactement le morceau de code en cause.
4. La partie help: montre souvent la correction. Ici, elle marque même le ! manquant avec un +.

Remettez le ! et tout refonctionne :

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

Sortie :

Hello, world!

▶ Essayez par vous-même

Une vérification plus rapide

cargo check cherche les erreurs sans construire de programme à exécuter. C’est bien plus rapide que cargo build sur les gros projets, et beaucoup de gens le lancent en permanence pendant qu’ils écrivent du code. Le code E0423 se recherche aussi : rustc --explain E0423 affiche une explication plus longue avec des exemples (en anglais).

Étape 5 : configurer votre éditeur (recommandé)

Pour le meilleur confort, installez l’extension rust-analyzer dans votre éditeur. Elle vous apporte l’autocomplétion, les messages d’erreur directement dans le code et des indications de type pendant que vous tapez.

• VS Code : installez l’extension rust-analyzer
• La plupart des autres éditeurs (JetBrains, Neovim, etc.) prennent aussi en charge rust-analyzer.

Astuce

Gardez les messages d’erreur du compilateur sous les yeux pendant votre apprentissage. Les erreurs de Rust sont réputées pour être utiles : elles expliquent en général ce qui ne va pas et comment le corriger.

Exercices

1. Trois lignes

Faites afficher trois lignes à votre programme : votre prénom, votre plat préféré et Je viens de lancer Rust !. Indice : un println! affiche une ligne, utilisez-en donc trois.

Voir la solution

fn main() {
    println!("Je m'appelle Camille");
    println!("J'aime la pizza");
    println!("Je viens de lancer Rust !");
}

Sortie :

Je m'appelle Camille
J'aime la pizza
Je viens de lancer Rust !

▶ Essayez par vous-même

2. Une petite bannière

Affichez une petite bannière comme celle ci-dessous, avec une ligne de signes = au-dessus et en dessous d’un titre. Ensuite, cassez-la exprès en supprimant un !, lancez cargo run, lisez l’erreur et corrigez-la. Indice : les lignes de = sont du simple texte dans println!, comme n’importe quel autre message.

Voir la solution

fn main() {
    println!("==============");
    println!("  BONJOUR RUST");
    println!("==============");
}

Sortie :

==============
  BONJOUR RUST
==============

▶ Essayez par vous-même

Récapitulatif

• Installez Rust avec rustup depuis rustup.rs.
• Vérifiez avec rustc --version et cargo --version.
• Créez un projet avec cargo new, lancez-le avec cargo run.
• Un projet contient un Cargo.toml (les réglages) et un src/main.rs (votre code).
• Lisez les erreurs du compilateur de haut en bas : quoi, où, et souvent un help: avec la correction.
• Installez rust-analyzer dans votre éditeur pour une expérience bien plus agréable.

Petit quiz

Petit quiz

1. Quel outil installe le compilateur Rust et cargo, et les garde à jour ?

rustup cargo rustc

2. Quel fichier décrit le nom, la version et les dépendances d’un projet Rust ?

src/main.rs target/debug/ Cargo.toml

3. Quelle commande compile seulement votre programme, sans l’exécuter ?

cargo run cargo build cargo new

Score : 0 / 3

Pour aller plus loin

• Installation — The Rust Book (en anglais) : l’installation sur chaque plateforme, la mise à jour avec rustup update et le dépannage.
• Hello, Cargo! — The Rust Book (en anglais) : un regard plus détaillé sur cargo new, cargo build, cargo run et cargo check.
• First Steps with Cargo — The Cargo Book (en anglais) : ce que crée cargo new et ce que signifie chaque ligne de Cargo.toml.
• The rustup book (en anglais) : installer d’autres toolchains, mettre Rust à jour et passer de stable à nightly.
• rust-analyzer (en anglais) : les guides de configuration pour VS Code, Neovim, Emacs et d’autres éditeurs.