Rust Cheatsheet

Voici la cheatsheet exhaustive en français pour Rust :

Bases & syntaxe

Variables et mutabilité

let x = 5; // immuable par défaut
let mut y = 10; // mutable

Utiliser mut lorsque vous devez modifier une valeur.

Types de données scalaires

let a: i32 = 42;
let b: f64 = 3.14;
let c: bool = true;
let d: char = 'a';

Choisissez le type qui correspond à vos besoins.

Tableaux et vecteurs

let arr: [i32; 5] = [0, 1, 2, 3, 4];
let vec = vec![1, 2, 3, 4, 5];

Utilisez des tableaux pour une longueur fixe et des vecteurs pour des tailles variables.

Structures de données

Dictionnaires (HashMap)

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("cle", "valeur");
if let Some(v) = map.get("cle") {
    println!("Valeur: {}", v);
}

Stockez des paires clé-valeur et recherchez rapidement avec get.

Option et Result

fn parse_number(s: &str) -> Result<i32, &'static str> {
    s.parse().map_err(|_| "Invalid number")
}

let num = match parse_number("10") {
    Ok(n) => n,
    Err(e) => panic!(e),
};

Utilisez Option pour expressions qui peuvent échouer et Result pour fonctions qui retournent un résultat.

Fonctions & methodes essentielles

Les fonctions

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let result = add(5, 10);

Déclarez et utilisez des fonctions avec des paramètres et un retour.

Les méthodes sur les types

struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Point { x, y }
    }

    fn distance(&self, other: &Point) -> f64 {
        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
    }
}

let p1 = Point::new(0.0, 0.0);
let p2 = Point::new(3.0, 4.0);
let dist = p1.distance(&p2);

Définissez des méthodes liées à vos types pour une utilisation fluide.

Patterns courants

Destructuration

struct Person {
    name: String,
    age: u8,
}

fn print_person(p: &Person) {
    match p {
        Person { name, age } => println!("Name: {}, Age: {}", name, age),
    }
}

let person = Person { name: "Alice".into(), age: 30 };
print_person(&person);

Destructurez les structs et enums pour accéder aux champs individuellement.

Match

fn classify(x: i32) -> &'static str {
    match x {
        1..=5 => "Petit",
        6..=10 => "Moyen",
        _ => "Grand",
    }
}

let size = classify(7);

Utilisez match pour des structures de contrôle complexes et expressifs.

Opérations avancées

Macros

macro_rules! say_hello {
    () => { println!("Hello!") };
}

say_hello!();

Créez vos propres macros pour simplifier le code répétitif.

Traits

trait Animal {
    fn make_sound(&self);
}

struct Dog;

impl Animal for Dog {
    fn make_sound(&self) {
        println!("Woof!");
    }
}

fn main() {
    let dog = Dog;
    dog.make_sound();
}

Utilisez les traits pour définir des comportements communs entre différents types.

Lifetimes

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

let s1 = String::from("hello");
let s2 = "world";
let result = longest(s1.as_str(), s2);

Gérez les durées de vie des références avec les lifetimes.

Debugging & outils

Utilisation du debugger

fn main() {
    let x = 5;
    println!("x: {}", x);
    // Démarrez le débogage avec `cargo debug` et placez un point d'arrêt ici.
}

Utilisez les points d'arrêt pour examiner l'état de votre programme.

Utilisation des outils de profiling

// Cargo.toml
[dependencies]
criterion = "0.4"

// src/main.rs
use criterion::{criterion_group, Criterion};

fn fibonacci(n: u32) -> u32 {
    match n {
        0 | 1 => n,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn criterion_benchmark(c: &mut Criterion) {
    c.bench_function("fibonacci", |b| b.to_block(|_| fibonacci(30)));
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);

Utilisez des outils comme Criterion pour analyser la performance de votre code.

Autres astuces et raccourcis

• Trait object : let dyn Trait = Box::new(value); pour utiliser des traits polymorphes.
• Box : alloue sur l'heap, utile pour les structures complexes ou les allocations dynamiques.
• Rustfmt : formate automatiquement votre code selon les meilleures pratiques Rust.

Cette cheatsheet couvre les aspects essentiels de Rust et devrait vous aider à coder plus efficacement en Rust. N'hésitez pas à ajouter d'autres éléments si nécessaire !