Debuter avec Rust

Démarrer avec Rust

Pourquoi Rust ?

Au cœur des défis technologiques contemporains, les langages de programmation évoluent constamment pour répondre aux besoins croissants en sécurité, performance et productivité. Un tel domaine est le développement web où la rapidité d'exécution, la fiabilité et la sécurité sont cruciaux. Rust est un excellent choix pour ce type de projet. Il offre une compilation optimisée, une gestion mémoire sécurisée et des erreurs évitées à l'état compilé. Un cas concret serait la construction d'une API web robuste qui nécessite des performances élevées et une sécurité maximale.

Prérequis

• Connaissances :
  • Bases du langage Rust
  • Connaissance de base en programmation (variables, structures de contrôle, fonctions)
• Outils à installer :
  • Rust : rustup install stable
  • Cargo (gestionnaire de projets) : Installation automatique avec rustup
  • Visual Studio Code (VSCode) ou un éditeur de code moderne
  • Terminal (pour exécuter des commandes)

Concepts fondamentaux

1. Variables et Mutabilité

// Déclaration d'une variable immuable
let x = 5;
## ❌ Erreur : impossible de modifier une variable immuable
x = 6; // Ceci causera une erreur

// Déclaration d'une variable mutable
let mut y = 10;
y = 20; // C'est valide

2. Types de données

// Entier
let a: i32 = 42;

// Flottant
let b: f64 = 3.14;

// Booléen
let c: bool = true;

// Chaîne de caractères
let d: &str = "Hello, Rust!";

3. Fonctions

fn main() {
    let result = add(2, 3);
    println!("La somme est : {}", result);
}

// Déclaration d'une fonction
fn add(x: i32, y: i32) -> i32 {
    x + y // La dernière expression est la valeur de retour
}

4. Structures et Enumerations

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

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

// Énumération
enum Direction {
    North,
    South,
    East,
    West,
}

Mise en pratique : Projet fil rouge

Mini-projet : Gestionnaire de tâches

Etapes 1 à 3 : Configuration du projet et création des fichiers

cargo new task_manager
cd task_manager
## Dans src/main.rs
rust
// src/main.rs
fn main() {
    println!("Bienvenue dans le gestionnaire de tâches !");
}

Étape 4 : Création d'une structure pour les tâches

struct Task {
    id: u32,
    description: String,
    completed: bool,
}

impl Task {
    fn new(id: u32, description: &str) -> Self {
        Task { 
            id,
            description: description.to_string(),
            completed: false, 
        }
    }

    fn mark_as_completed(&mut self) {
        self.completed = true;
    }
}

Étape 5 : Ajout d'une fonction pour ajouter des tâches

fn add_task(tasks: &mut Vec<Task>, description: &str) {
    let new_task = Task::new(tasks.len() as u32 + 1, description);
    tasks.push(new_task);
}

Étape 6 : Ajout d'une fonction pour marquer une tâche comme terminée

fn complete_task(tasks: &mut Vec<Task>, id: u32) {
    if let Some(task) = tasks.iter_mut().find(|t| t.id == id) {
        task.mark_as_completed();
        println!("Tâche {} marquée comme terminée.", id);
    } else {
        println!("Aucune tâche avec l'ID {}.", id);
    }
}

Étape 7 : Ajout d'une fonction pour afficher les tâches

fn display_tasks(tasks: &Vec<Task>) {
    for task in tasks {
        if task.completed {
            println!("[✓] {}: {}", task.id, task.description);
        } else {
            println!("[ ] {}: {}", task.id, task.description);
        }
    }
}

Étape 8 : Mise à jour de la fonction main

fn main() {
    let mut tasks = Vec::new();
    
    add_task(&mut tasks, "Faire les courses");
    add_task(&mut tasks, "Nettoyer la maison");

    display_tasks(&tasks);

    complete_task(&mut tasks, 1);
    display_tasks(&tasks);
}

Erreurs fréquentes et debugging

Erreur 1 : Tentative de modifier une variable immuable

let x = 5;
x = 6; // Cela causera une erreur

Correction : Déclarer la variable comme mutable

let mut y = 10;
y = 20; // Valide

Erreur 2 : Utilisation incorrecte de cargo run

cargo run --release # Cela compile en mode release

Correction : Utiliser simplement cargo run pour le développement

cargo run

Erreur 3 : Tentative d'accéder à un élément non présent dans un vecteur

let tasks = vec![Task::new(1, "Acheter du pain")];
tasks.get(10); // Cela causera une erreur

Correction : Vérifier si l'élément existe avant de l'accéder

if let Some(task) = tasks.iter().find(|t| t.id == 10) {
    println!("Tâche trouvée : {}", task.description);
} else {
    println!("Aucune tâche avec l'ID 10.");
}

Pour aller plus loin

1. Macros et systèmes de compilation

Explorez les macros Rust pour créer du code généré dynamiquement à la compilation.

2. Trait Object et Polymorphisme

Apprenez à utiliser les trait objects et le polymorphisme en Rust pour gérer des objets d'interfaces différentes.

3. Multithreading et Concurrence

Découvrez comment Rust gère la concurrence de manière sécurisée, offrant des outils puissants pour développer des applications multi-threadées.

Défi pratique : Créer une application CLI pour un gestionnaire de contacts

Construire une application en ligne de commande qui permet d'ajouter, modifier et afficher des contacts. Utilisez les structures et méthodes que vous avez apprises dans ce tutoriel.

Ce tutoriel a été conçu pour vous aider à démarrer avec Rust en offrant une compréhension claire des concepts fondamentaux et en vous guidant à travers la création d'un projet complet. N'oubliez pas de pratiquer régulièrement pour améliorer vos compétences en Rust !