Aide-mémoire Rust

Une page de référence rapide pour retrouver ce que vous voulez vérifier sans relire toute une leçon. Chaque section renvoie à la page qui l’explique en détail.

Mots-clés

Mot-clé	Signification
`let`	Déclarer une variable (Variables)
`mut`	Rendre une variable ou une référence mutable (Variables)
`const`	Déclarer une constante (Variables)
`fn`	Déclarer une fonction (Fonctions)
`struct`	Déclarer une struct (Structs)
`enum`	Déclarer une enum (Enums)
`impl`	Ajouter des méthodes à un type (Structs, Traits)
`trait`	Déclarer un trait (Traits)
`match`	Faire du pattern matching sur une valeur (Match)
`if let` / `while let`	Tester un seul motif (If Let / While Let)
`loop` / `while` / `for`	Les trois sortes de boucles (Boucles, While, For)
`break` / `continue`	Contrôler une boucle (Break/Continue)
`mod`	Déclarer un module (Modules)
`pub`	Rendre un élément public en dehors de son module (Modules)
`use`	Importer un chemin dans la portée (Modules)
`unsafe`	Débloquer les pointeurs bruts et d’autres opérations que vous vérifiez vous-même (Unsafe)
`move`	Obliger une closure à prendre l’ownership des valeurs capturées (Concurrence)
`&` / `&mut`	Emprunter une valeur / l’emprunter de façon mutable (Borrowing)

Méthodes courantes de String

Méthode	Ce qu’elle fait
`.len()`	Longueur en octets
`.trim()`	Supprime les espaces au début et à la fin
`.to_uppercase()` / `.to_lowercase()`	Passer en majuscules / minuscules
`.contains(pat)`	Indique si une sous-chaîne ou un motif est présent
`.replace(from, to)`	Remplace toutes les occurrences
`.push_str(s)`	Ajoute un `&str` à la fin
`.push(c)`	Ajoute un seul `char` à la fin
`.chars()`	Parcourt la chaîne caractère par caractère
`.split(pat)`	Découpe en un itérateur de sous-chaînes
`.parse::<T>()`	Convertit du texte en un autre type (renvoie un `Result`)

Voir la page Les chaînes en Rust pour les détails et des exemples.

Méthodes courantes de Vec

Méthode	Ce qu’elle fait
`.push(x)`	Ajoute à la fin
`.pop()`	Retire et renvoie le dernier élément (`Option`)
`.remove(i)`	Retire l’élément à l’indice `i`
`.len()`	Nombre d’éléments
`.is_empty()`	Indique si le vecteur est vide
`.get(i)`	Accès sûr par indice (`Option`, pas de panic)
`.iter()`	Parcourt par référence
`.contains(&x)`	Indique si une valeur est présente
`.sort()`	Trie sur place
`.sort_by_key(\|x\| ...)`	Trie selon un champ ou une clé calculée
`.dedup()`	Supprime les doublons consécutifs (triez d’abord)

Voir les pages Les vecteurs en Rust, Trier et rechercher et Les itérateurs en Rust pour les détails et des exemples.

Quelle collection choisir ?

Type	À utiliser quand vous avez besoin…
`Vec<T>`	d’une liste ordonnée qui peut grandir
`HashMap<K, V>`	de retrouver rapidement une valeur à partir d’une clé
`HashSet<T>`	d’éléments uniques et de vérifier vite « est-ce que c’est dedans ? »
`BTreeMap<K, V>`	de paires clé-valeur gardées triées par clé
`VecDeque<T>`	d’une file : ajouter et retirer aux deux bouts

Voir les pages HashMap en Rust et HashSet et BTreeMap pour les détails et des exemples.

Option et Result

Méthode	Fonctionne sur	Ce qu’elle fait
`.unwrap()`	Les deux	Récupère la valeur ; panic si `None`/`Err`
`.expect("msg")`	Les deux	Comme `.unwrap()`, avec un message de panic personnalisé
`.unwrap_or(default)`	Les deux	Récupère la valeur, ou une valeur de repli
`.is_some()` / `.is_none()`	`Option`	Indique de quelle variante il s’agit
`.is_ok()` / `.is_err()`	`Result`	Indique de quelle variante il s’agit
`?`	Les deux	Renvoie immédiatement en cas de `None`/`Err`

Voir les pages Option en Rust et Result en Rust pour les détails et des exemples.

Spécificateurs de formatage (println!, format!)

Spécificateur	Ce qu’il affiche
`{}`	Affichage normal (nécessite le trait `Display`)
`{:?}`	Format de débogage (Debug)
`{:#?}`	Format de débogage indenté, plus lisible
`{:.2}`	2 décimales
`{:5}`	Complète jusqu’à une largeur de 5
`{name}`	Insère directement la variable nommée `name`

Voir la page Afficher du texte en Rust pour les détails et des exemples.

Commandes Cargo

Commande	Ce qu’elle fait
`cargo new name`	Crée un nouveau projet
`cargo run`	Compile et exécute
`cargo check`	Vérifie rapidement les erreurs, sans produire de binaire
`cargo test`	Lance vos tests
`cargo add crate`	Ajoute une dépendance
`cargo fmt`	Formate votre code
`cargo clippy`	Analyse votre code pour repérer les erreurs courantes
`cargo build --release`	Compile un binaire optimisé

Voir la page Cargo et les crates pour les détails et des exemples.

Syntaxe des intervalles (ranges)

Syntaxe	Signification
`1..5`	De 1 à 5, 5 non compris
`1..=5`	De 1 à 5, 5 compris
`..3`	Du début jusqu’à 3, 3 non compris
`2..`	De 2 jusqu’à la fin
`..`	Tout

Voir les pages For en Rust et Les slices en Rust pour les détails et des exemples.

Crates populaires

Vous avez besoin…	Crate	Leçon
de JSON (et d’autres formats)	`serde` + `serde_json`	JSON avec Serde
de code asynchrone, de minuteurs, de réseau	`tokio`	Async/Await
d’une interface en ligne de commande	`clap`	Outil CLI avec clap
de gérer les erreurs facilement	`anyhow`, `thiserror`	anyhow et thiserror
de nombres aléatoires	`rand`	Nombres aléatoires
d’expressions régulières	`regex`	Expressions régulières
de dates et d’heures	`chrono`	Dates et heures
de journalisation (logging)	`log` + `env_logger`, `tracing`	Journalisation (logging)
d’un serveur web	`axum`	API web avec Axum

Ajoutez n’importe laquelle avec cargo add <crate>. Voir Cargo et les crates pour savoir comment choisir une bonne crate.

Pour aller plus loin

Rust Language Cheat Sheet — cheats.rs: un aide-mémoire d’une page bien plus complet, de la syntaxe à la disposition en mémoire (en anglais).
Annexe B : opérateurs et symboles — The Rust Book: tous les opérateurs et symboles de Rust et leur signification (en anglais).
std::fmt — documentation de la bibliothèque standard: toute la syntaxe de formatage de println! et format! : largeur, remplissage, précision… (en anglais).
Les commandes Cargo — The Cargo Book: chaque commande cargo et ses options (en anglais).