Aide-mémoire Rust
Dernière mise à jour
Hello World et structure
Un programme Rust démarre à fn main ; les instructions se terminent par des points-virgules.
| Opération | Syntaxe |
|---|---|
| Point d'entrée | fn main() { ... } |
| Afficher une ligne | println!("Hello, World!"); |
| Afficher avec des valeurs | println!("{} is {}", name, age); |
| Afficher la forme debug | println!("{:?}", value); |
| Commentaire de ligne | // comment |
| Utiliser un élément d'un module | use std::collections::HashMap; |
| Construire et exécuter | cargo run |
| Construire un binaire de release | cargo build --release |
Variables et types (let / mut)
Les liaisons sont immuables par défaut ; ajoutez mut pour autoriser la réaffectation.
| Opération | Syntaxe |
|---|---|
| Liaison immuable | let x = 5; |
| Liaison mutable | let mut count = 0; |
| Type explicite | let age: u32 = 30; |
| Constante | const MAX: u32 = 100; |
| Masquage (shadowing) | let x = x + 1; |
| Types entiers | i32, u32, i64, usize |
| Autres scalaires | f64, bool, char |
| Tuple | let pair: (i32, &str) = (1, "a"); |
| Conversion de type | let f = x as f64; |
Contrôle de flux
if est une expression, et Rust possède trois formes de boucle.
| Opération | Syntaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If en tant qu'expression | let y = if x > 0 { 1 } else { -1 }; |
| Boucle infinie | loop { ... } |
| Boucle renvoyant une valeur | let v = loop { break 5; }; |
| Boucle while | while x < 100 { ... } |
| For sur une plage | for i in 0..10 { ... } |
| For sur une collection | for item in &items { ... } |
| Break / continue | break;, continue; |
Fonctions
La dernière expression (sans point-virgule) est la valeur de retour.
| Opération | Syntaxe |
|---|---|
| Fonction de base | fn add(a: i32, b: i32) -> i32 { a + b } |
| Retour explicite | fn f() -> i32 { return 5; } |
| Sans valeur de retour | fn log(msg: &str) { ... } |
| Prendre une référence | fn len(s: &String) -> usize { s.len() } |
| Fermeture | let add = |a, b| a + b; |
| Fermeture avec type | let sq = |x: i32| -> i32 { x * x }; |
| Fonction en argument | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership et emprunt
Chaque valeur a un seul propriétaire ; les références l'empruntent sans en prendre possession.
| Opération | Syntaxe |
|---|---|
| Déplacement (transfert de propriété) | let b = a; (a n'est plus valide) |
| Clone (copie profonde) | let b = a.clone(); |
| Emprunt immuable | let r = &x; |
| Emprunt mutable | let r = &mut x; |
| Emprunt dans une fonction | fn read(s: &String) { ... } |
| Déréférencement | *r |
| Règle d'emprunt | Plusieurs & OU un seul &mut à la fois, pas les deux |
| Slice (emprunte une plage) | let part = &arr[1..3]; |
Structures et enums
Les structures regroupent des données liées ; les enums modélisent une valeur qui est l'une de plusieurs variantes.
| Opération | Syntaxe |
|---|---|
| Définir une structure | struct Point { x: i32, y: i32 } |
| Créer une instance | let p = Point { x: 1, y: 2 }; |
| Accéder à un champ | p.x |
| Structure tuple | struct Pair(i32, i32); |
| Méthode (bloc impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Fonction associée | impl Point { fn new() -> Self { ... } } |
| Définir un enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum avec champs nommés | enum Msg { Move { x: i32, y: i32 } } |
| Dériver des traits | #[derive(Debug, Clone)] |
Filtrage par motif (match)
match compare une valeur à des motifs et doit être exhaustif.
| Opération | Syntaxe |
|---|---|
| Filtrer sur des valeurs | match x { 1 => "one", _ => "other" } |
| Filtrer un enum | match shape { Shape::Circle(r) => ... } |
| Filtrer une plage | match n { 1..=5 => ..., _ => ... } |
| Lier avec une garde | match x { n if n > 0 => ... } |
| Filtrer un tuple | match point { (0, y) => ..., (x, _) => ... } |
| if let (motif unique) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Déstructurer une structure | let Point { x, y } = p; |
Traits et génériques
Les traits définissent un comportement partagé ; les génériques font fonctionner le code sur de nombreux types.
| Opération | Syntaxe |
|---|---|
| Définir un trait | trait Area { fn area(&self) -> f64; } |
| Implémenter un trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Méthode par défaut | trait Greet { fn hi(&self) { ... } } |
| Fonction générique | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Structure générique | struct Wrapper<T> { value: T } |
| Contrainte de trait (where) | fn f<T>(x: T) where T: Display { ... } |
| Argument impl Trait | fn print(item: impl Display) { ... } |
| Objet trait | let shapes: Vec<Box<dyn Area>> = ...; |
Gestion des erreurs (Result / Option)
Rust modélise l'absence avec Option et les erreurs récupérables avec Result.
| Opération | Syntaxe |
|---|---|
| Valeur optionnelle | Option<T> : Some(v) ou None |
| Type Result | Result<T, E> : Ok(v) ou Err(e) |
| Renvoyer un Result | fn read() -> Result<String, Error> { ... } |
| Propager avec ? | let data = read()?; |
| Unwrap (panique sur None/Err) | opt.unwrap() |
| Valeur par défaut | opt.unwrap_or(0) |
| Mapper une valeur | opt.map(|v| v + 1) |
| Gérer les deux branches | match res { Ok(v) => ..., Err(e) => ... } |
| Convertir Option en Result | opt.ok_or("missing")? |
Collections courantes (Vec / HashMap)
Vec est un tableau extensible ; HashMap est un magasin clé-valeur.
| Opération | Syntaxe |
|---|---|
| Créer un vecteur | let mut v: Vec<i32> = Vec::new(); |
| Littéral de vecteur | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Accès par indice | v[0] |
| Accès sûr | v.get(0) renvoie Option<&T> |
| Itérer | for x in &v { ... } |
| Longueur | v.len() |
| Créer une map | let mut m: HashMap<String, i32> = HashMap::new(); |
| Insérer / obtenir | m.insert(k, v);, m.get(&k) |
| API Entry | *m.entry(k).or_insert(0) += 1; |
La syntaxe Rust que vous utilisez le plus, sur une seule page. Cet aide-mémoire Rust est une référence rapide pour le cœur du langage - variables et mutabilité, ownership et emprunt, structures et enums, filtrage par motif, traits et génériques, ainsi que les types Result et Option qui sous-tendent la gestion des erreurs de Rust.
Tout ce qui figure ici est du Rust standard qui compile sur une chaîne d'outils stable récente. Copiez ce dont vous avez besoin, ou essayez chaque extrait en direct dans le playground Rust - aucune installation de cargo requise.
FAQ de l'aide-mémoire Rust
Cet aide-mémoire Rust est-il gratuit ?
Oui. Cet aide-mémoire Rust est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver un motif de match, une contrainte de trait ou une méthode de collection.
Que sont l'ownership et l'emprunt en Rust ?
L'ownership est le modèle de mémoire de Rust : chaque valeur a exactement un propriétaire, et la valeur est libérée quand ce propriétaire sort de portée. L'emprunt vous permet d'accéder à une valeur sans en prendre possession au moyen d'une référence -
&x pour un emprunt immuable ou &mut x pour un emprunt mutable. Le compilateur impose une règle : vous pouvez avoir plusieurs emprunts immuables ou exactement un emprunt mutable à la fois, ce qui empêche les accès concurrents au moment de la compilation.Quelle est la différence entre Result et Option en Rust ?
Option<T> représente une valeur qui peut être absente - c'est soit Some(v), soit None, et vous l'utilisez lorsqu'il n'y a aucune erreur à signaler, juste une valeur manquante. Result<T, E> représente une opération qui peut échouer - c'est soit Ok(v), soit Err(e), portant une valeur d'erreur quand quelque chose tourne mal. Utilisez Option pour « peut-être présent » et Result pour « cela peut échouer » ; l'opérateur ? propage les deux.Puis-je m'entraîner à Rust en ligne ?
Oui. Ouvrez le playground Rust pour compiler et exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucun cargo ni chaîne d'outils à installer. Quand vous voulez de la structure, le cours Rust interactif gratuit de Coddy vous emmène des variables et de l'ownership jusqu'aux traits et à la gestion des erreurs, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des sujets les plus courants (variables, contrôle de flux, fonctions) jusqu'aux plus avancés (traits, génériques, gestion des erreurs), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers l'ownership et le reste.
Ressources connexes
Plus d'aide-mémoires
