> Apprendre Rust de zéro : installation avec rustup et cargo, ownership et borrow, types, premier programme et raisons de choisir Rust en 2026.

*Source : https://coder-studio.com/tutoriels/apprendre-rust/*

---

[// Rust](https://coder-studio.com/tutoriels/)

# Apprendre Rust : le guide pour bien démarrer

Par **Kévin Papot** · publié le 6 mai 2026

**Apprendre Rust**, c’est adopter un langage qui a rebattu les cartes de la programmation système. Sa promesse est singulière : la performance du C ou du C++, mais avec des garanties de sécurité mémoire vérifiées à la compilation, sans ramasse-miettes. Réputé exigeant, Rust récompense l’effort par une confiance rare dans son code. Ce guide vous accompagne pas à pas : installation, premier programme, et surtout ses concepts phares — l’ownership et le borrow — qui font toute sa singularité.

## Pourquoi Rust ?

Rust répond à un problème vieux comme la programmation système : comment gérer la mémoire manuellement sans introduire de bugs dangereux ? Les langages comme le C offrent le contrôle mais laissent la porte ouverte aux erreurs mémoire (accès à une zone libérée, dépassement de tampon). Rust apporte une réponse originale :

-   **Sécurité mémoire garantie** : le compilateur refuse le code susceptible de provoquer ces erreurs, sans coût à l’exécution.
-   **Performance native** : Rust compile en code machine, sans ramasse-miettes qui interromprait le programme.
-   **Concurrence sereine** : les mêmes règles qui protègent la mémoire préviennent une large classe de bugs de programmation parallèle.

Ces atouts expliquent son adoption croissante dans les systèmes d’exploitation, les navigateurs, les outils en ligne de commande et l’embarqué. Si la comparaison avec les langages historiques vous intéresse, notre article [Rust vs C++](https://coder-studio.com/tutoriels/rust-vs-cpp/) creuse la question. Rust demande de la patience au début, mais forme durablement au raisonnement sur la mémoire.

## Installer Rust avec rustup

L’outil officiel d’installation est **rustup**, qui gère le compilateur et les versions. Sur macOS et Linux, une seule commande suffit ; sur Windows, un installeur est fourni sur le site officiel. La commande classique est :

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Une fois l’installation terminée, vérifiez que tout fonctionne :

```
rustc --version
cargo --version
```

`rustc` est le compilateur, mais vous l’appellerez rarement directement. En pratique, on passe par **Cargo**, l’outil tout-en-un de Rust : il gère la compilation, les dépendances, les tests et la documentation. Côté éditeur, VS Code avec l’extension **rust-analyzer** offre une excellente autocomplétion et signale les erreurs en temps réel.

## Votre premier programme avec Cargo

Cargo structure vos projets. Créez-en un nouveau :

```
cargo new bonjour
cd bonjour
cargo run
```

Cargo génère l’arborescence, compile et exécute. Le fichier `src/main.rs` contient le point d’entrée :

```
fn main() {
    let nom = "Coder Studio";
    println!("Bonjour, {nom} !");
}
```

Quelques observations utiles. La fonction `main` est le point de départ ; `let` déclare une variable ; `println!` est une **macro** (le `!` la distingue d’une fonction ordinaire) qui gère l’affichage formaté. Notez aussi qu’en Rust, les variables sont **immuables par défaut** : une fois affectée, une valeur ne change plus, sauf mention explicite.

```
fn main() {
    let mut compteur = 0; // mut = mutable
    compteur += 1;
    println!("Compteur : {compteur}");
}
```

Ce choix par défaut n’est pas anodin : il pousse à un code plus prévisible, où l’on sait exactement ce qui peut changer.

## Les types essentiels

Rust est fortement et statiquement typé, mais il **infère** souvent le type, ce qui allège l’écriture. Les types fondamentaux ressemblent à ceux des autres langages :

```
fn main() {
    let age: i32 = 30;          // entier signé 32 bits
    let prix: f64 = 19.90;      // flottant 64 bits
    let actif: bool = true;     // booléen
    let lettre: char = 'A';     // caractère Unicode
    let nom: &str = "Léa";      // chaîne (référence)
}
```

Pour regrouper des données, Rust propose notamment les **tuples**, les **tableaux** de taille fixe et les **vecteurs** (`Vec`) de taille variable :

```
fn main() {
    let point: (i32, i32) = (48, 2);
    let mut courses: Vec<&str> = vec!["pain", "lait"];
    courses.push("œufs");

    for article in &courses {
        println!("{article}");
    }
}
```

Le `Vec` est la structure de collection la plus utilisée au quotidien. Remarquez le `&` devant `courses` dans la boucle : nous **empruntons** la collection au lieu de la consommer — ce qui nous amène au cœur de Rust.

## Ownership : le concept central

L’**ownership** (propriété) est l’idée qui distingue Rust de tous les autres langages grand public. Elle repose sur trois règles simples :

1.  Chaque valeur a un unique **propriétaire** (owner).
2.  Il ne peut y avoir qu’un seul propriétaire à la fois.
3.  Quand le propriétaire sort de portée, la valeur est automatiquement libérée.

Concrètement, affecter une valeur non copiable à une autre variable **transfère** sa propriété :

```
fn main() {
    let a = String::from("bonjour");
    let b = a;              // la propriété passe de a à b
    // println!("{a}");     // ERREUR : a n'est plus valide
    println!("{b}");        // OK
}
```

Ce mécanisme, appelé _move_, garantit qu’aucune donnée n’est libérée deux fois, sans avoir besoin d’un ramasse-miettes. C’est déroutant au début, mais c’est exactement ce qui rend Rust sûr.

## Borrowing : emprunter sans posséder

Transférer la propriété à chaque usage serait pénible. Rust permet donc d’**emprunter** une valeur via une référence `&`, sans en prendre la propriété :

```
fn longueur(texte: &String) -> usize {
    texte.len()
} // texte est emprunté, pas consommé

fn main() {
    let phrase = String::from("bonjour");
    let n = longueur(&phrase);
    println!("{phrase} fait {n} caractères"); // phrase reste utilisable
}
```

Les emprunts obéissent à une règle stricte, vérifiée par le **borrow checker** : à un instant donné, on peut avoir soit _plusieurs_ références en lecture seule (`&`), soit _une seule_ référence mutable (`&mut`), mais jamais les deux. Cette règle élimine à la compilation les conflits d’accès concurrents.

```
fn main() {
    let mut score = 10;
    let r = &mut score;   // emprunt mutable unique
    *r += 5;
    println!("{score}");  // 15
}
```

> **Bonne pratique — Écouter le compilateur, pas le combattre** Face au borrow checker, le réflexe du débutant est de le contourner. Prenez plutôt ses messages comme un professeur : ils sont réputés parmi les plus pédagogiques de l’industrie et pointent souvent un vrai problème de conception. Comprendre _pourquoi_ le code est refusé est la clé pour progresser.

## Gérer l’absence et l’erreur sans null

Rust n’a pas de `null`. L’absence de valeur se modélise avec le type `Option`, et les erreurs récupérables avec `Result`. Le compilateur vous **oblige** à traiter les deux cas, ce qui supprime toute une catégorie de plantages :

```
fn diviser(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    match diviser(10.0, 2.0) {
        Some(r) => println!("Résultat : {r}"),
        None => println!("Division par zéro"),
    }
}
```

Cette approche, héritée de la programmation fonctionnelle, force à rendre l’échec explicite. C’est plus verbeux qu’un `null`, mais infiniment plus sûr — le compilateur refuse d’oublier un cas.

## Progresser efficacement en Rust

Rust s’apprend en écrivant, en butant sur le borrow checker et en comprenant ses messages. Quelques pistes concrètes pour ancrer les bases :

-   Lisez _The Rust Programming Language_ (le « Book »), la référence gratuite et officielle.
-   Pratiquez avec **Rustlings**, une série d’exercices guidés à corriger.
-   Construisez un petit outil en ligne de commande : un compteur de mots, un convertisseur. Le terrain CLI met en valeur les forces du langage.
-   Explorez **crates.io**, le registre de bibliothèques, avec des paquets comme `serde` (sérialisation) ou `clap` (arguments CLI).

L’erreur classique est de vouloir aller trop vite en luttant contre le langage. Rust demande d’accepter un modèle mental nouveau. Une fois l’ownership intégré, on écrit du code performant avec une tranquillité d’esprit que peu de langages procurent.

## À lire ensuite

-   [Rust vs C++ : quel langage système choisir ?](https://coder-studio.com/tutoriels/rust-vs-cpp/)
-   [Apprendre Go : premiers pas avec Golang](https://coder-studio.com/tutoriels/apprendre-go/)
-   [Le langage C : les fondamentaux à connaître](https://coder-studio.com/tutoriels/langage-c/)