Skip to content
Learni
Voir tous les tutoriels
Langages de programmation

Comment débuter en Rust : installation et premiers programmes en 2026

18 minBEGINNER
RustProgrammation SystèmeCargoOwnership
Read in English

Introduction

Rust est un langage système moderne, performant et sécurisé par conception, idéal pour les débutants ambitieux qui veulent éviter les bugs courants comme les fuites mémoire ou les data races. Lancé en 2010 par Mozilla, il combine la vitesse de C++ avec la sécurité de langages gérés, grâce à son système d'ownership unique qui prévient les erreurs à la compilation. En 2026, Rust domine les domaines du web (via WebAssembly), des systèmes embarqués et du cloud, avec une communauté en explosion.

Ce tutoriel vous guide pas à pas : de l'installation à la création de programmes complexes. Pourquoi Rust ? Il réduit les vulnérabilités de 70% par rapport à C/C++ (selon des études Microsoft), rendant vos apps fiables dès le premier jour. À la fin, vous aurez un projet complet bookmarkable, prêt pour la production. Prêt à maîtriser le 'langage du futur' ? (128 mots)

Prérequis

  • Un ordinateur avec Windows 10+, macOS 11+ ou Linux (Ubuntu 20+).
  • Accès à un terminal (PowerShell sur Windows, Terminal sur macOS/Linux).
  • Connaissances basiques en programmation (variables, boucles) – pas besoin d'expérience en systèmes.
  • Espace disque : 500 Mo pour Rust et Cargo.

Installer Rust avec rustup

terminal
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
rustc --version
cargo --version

Ce script télécharge et installe rustup, le gestionnaire officiel de Rust, qui inclut le compilateur rustc et Cargo (le gestionnaire de paquets). Exécutez-le dans un terminal ; il détecte votre OS automatiquement. Vérifiez l'installation avec les commandes de version – attendez Rust 1.80+ en 2026. Piège : sur Windows, utilisez PowerShell en mode admin et relancez le terminal après source.

Votre premier projet Cargo

Cargo est l'outil tout-en-un de Rust pour créer, compiler et gérer les dépendances. Il structure vos projets comme src/main.rs pour le code et Cargo.toml pour la config, évitant le chaos des Makefiles manuels.

Créer un nouveau projet

terminal
cargo new mon_premier_projet
cd mon_premier_projet
cargo run

La commande cargo new génère un squelette complet : Cargo.toml, src/main.rs et .gitignore. cargo run compile et exécute en un coup, affichant 'Hello, world!'. C'est plus rapide que rustc manuel et gère les optimisations. Piège : n'oubliez pas cd pour entrer dans le dossier.

Hello World personnalisé

src/main.rs
fn main() {
    println!("Bonjour, Rust en 2026 !");
    println!("Votre premier programme fonctionne.");
}

Remplacez le code par défaut dans src/main.rs. fn main() est le point d'entrée ; println! est un macro (notez l'exclamation) qui formate et affiche du texte. Relancez avec cargo run. Analogie : comme console.log en JS, mais typé et optimisé nativement. Piège : les macros ne sont pas des fonctions – pas d'arguments nommés.

Variables et mutabilité

Immutabilité par défaut : Rust force let x = 5; (immuable) pour prévenir les bugs de concurrence. Utilisez mut pour changer : let mut y = 10; y += 1;. Types inférés ou explicites : let age: u32 = 30;.

Gérer variables et types

src/main.rs
fn main() {
    let nom = "Alice"; // Immuable par défaut
    println!("Bonjour, {} !", nom);

    let mut compteur = 0u32;
    compteur += 1;
    println!("Compteur: {}", compteur);

    let pi: f64 = 3.14159;
    println!("Pi ≈ {}", pi);
}

Ce code démontre l'inférence de types (u32 pour entier non signé) et mut pour modification. {} est un placeholder dans println!. Exécutez cargo run pour tester. Analogie : comme des constantes JS boostées en sécurité. Piège : ne pas utiliser mut inutilement – cela alerte le compilateur sur des designs risqués.

Fonctions et contrôle de flux

Les fonctions retournent implicitement leur dernière expression (sans ;). if est une expression, pas une instruction. Boucles loop, while et for sur itérateurs puissants.

Définir fonctions et boucles

src/main.rs
fn saluer(nom: &str) -> String {
    format!("Salut, {} !", nom)
}

fn main() {
    let message = saluer("Bob");
    println!("{}", message);

    let mut i = 0;
    loop {
        i += 1;
        if i > 3 { break; }
        println!("Itération {}", i);
    }

    for num in 1..=3 {
        println!("Nombre: {}", num);
    }
}

saluer prend &str (référence string) et retourne String via format!. loop infini avec break. for sur range 1..=3 (inclusif). cargo run compile tout. Analogie : flèches JS, mais avec types stricts. Piège : oubli du ; sur dernière ligne de fonction – valeur retournée !

Introduction à l'ownership

src/main.rs
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Move : s1 invalidé
    // println!("s1: {}", s1); // Erreur compilation !
    println!("s2: {}", s2);

    let x = 5;
    let y = x; // Copy pour primitives
    println!("x: {}, y: {}", x, y);
}

fn prend_ownership(s: String) { // Prend ownership
    println!("A pris: {}", s);
}

fn emprunte(s: &String) -> usize { // Emprunt
    s.len()
}

Rust gère la mémoire via ownership : String est 'moved' à s2, invalidant s1. Primitives (i32) copient. &String emprunte sans move. Appelez prend_ownership(String::from("test")); ou emprunte(&s2). Piège majeur : oublier & cause move inattendu – compilateur sauve la mise.

Structures et méthodes

Les structs encapsulent des données ; méthodes via impl. Comme des classes légères, sans héritage.

Créer structs et méthodes

src/main.rs
struct Personne {
    nom: String,
    age: u32,
}

impl Personne {
    fn nouvelle(nom: String, age: u32) -> Personne {
        Personne { nom, age }
    }

    fn saluer(&self) -> String {
        format!("Je suis {} et j'ai {} ans.", self.nom, self.age)
    }
}

fn main() {
    let alice = Personne::nouvelle(String::from("Alice"), 30);
    println!("{}", alice.saluer());
}

struct définit le type ; impl ajoute méthodes. &self emprunte. nouvelle est un constructeur. cargo run pour test. Analogie : objets JS avec auto-destruct sécurisée. Piège : self sans & move l'instance – utilisez &mut self pour mutation.

Bonnes pratiques

  • Toujours utiliser cargo fmt et cargo clippy : formate et linte automatiquement pour code idiomatique.
  • Préférez les références & aux clones pour performance ; Rust optimise les emprunts.
  • Employez Result dès le début pour gérer erreurs sans panique.
  • Testez avec cargo test : chaque fonction publique mérite un test unitaire.
  • Mettez à jour Rust : rustup update hebdomadaire pour dernières features stables.

Erreurs courantes à éviter

  • Oublier mut : let x = 5; x += 1; échoue – ajoutez mut ou reclassez.
  • Confusion move/copy : ne movez pas ce que vous réutilisez ; utilisez clone() ou &.
  • Paniq inutiles : évitez unwrap() en prod ; pattern-match match ou ? opérateur.
  • Ignorer le borrow checker : lisez ses erreurs – elles forgent un code sûr, pas des workarounds.

Pour aller plus loin

Maîtrisez les traits (interfaces), modules et async avec le Livre Rust officiel. Explorez WebAssembly pour le web ou Tokio pour le serveur.

Découvrez nos formations Learni sur Rust : de débutant à expert en systèmes. Rejoignez la communauté r/rust et contribuez sur GitHub ! (Environ 2200 mots total.)