Rust en 2025 : Guide complet pour débutants à partir de zéro

Introduction : Pourquoi Rust est le choix de 2025

En 2025, Rust continue de conquérir avec confiance le cœur des développeurs du monde entier. Selon l'enquête annuelle Stack Overflow, Rust a été reconnu comme le langage de programmation le plus apprécié pendant huit années consécutives. Ses principaux avantages sont la sécurité mémoire sans ramasse-miettes et des performances de premier ordre, comparables à C et C++. Si vous connaissez Python mais souhaitez apprendre à écrire des applications système rapides et fiables, du WebAssembly, ou même des systèmes d'exploitation — Rust sera votre prochaine étape idéale.

Dans cet article, nous allons décomposer par où commencer à apprendre Rust en 2025 : comment installer la chaîne d'outils, écrire votre premier programme et comprendre les concepts clés. C'est parti !

1. Installer Rust et découvrir Cargo

La première chose à faire est d'installer le compilateur rustc et le gestionnaire de paquets Cargo. En 2025, le processus est aussi simple que possible.

Installation via rustup

La méthode officielle et recommandée est d'utiliser l'utilitaire rustup. Ouvrez un terminal et exécutez la commande :

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

Le script proposera les paramètres standard — appuyez simplement sur Entrée. Après l'installation, redémarrez votre terminal ou exécutez :

source $HOME/.cargo/env

Vérifiez que tout fonctionne :

rustc --versioncargo --version

Premier programme : "Hello, world!"

Créons un nouveau projet en utilisant Cargo :

cargo new hello_rustcd hello_rust

Cargo créera la structure de répertoires. Ouvrez le fichier src/main.rs — il contient déjà un modèle :

fn main() {    println!("Hello, world!");}

Compilez et exécutez le programme avec une seule commande :

cargo run

Vous verrez le salut tant convoité. Félicitations, vous avez écrit votre premier programme Rust !

2. Bases de la syntaxe Rust : Variables, types et fonctions

Rust est un langage à typage statique fort, mais le compilateur déduit souvent les types tout seul. Décomposons les constructions de base.

Variables et immuabilité

Par défaut, toutes les variables en Rust sont immuables. C'est l'une des principales caractéristiques du langage, garantissant la sécurité.

fn main() {    let x = 5;          // variable immuable    // x = 6;           // Erreur ! Impossible de changer    let mut y = 10;     // variable mutable (mut)    y += 5;             // Maintenant y = 15    println!("x = {}, y = {}", x, y);}

Types de données

Rust prend en charge les types familiers : entiers (i32, u64), nombres à virgule flottante (f64), booléen (bool), caractère (char), et chaînes de caractères (String, &str).

fn main() {    let a: i32 = -42;          // entier signé    let b: u8 = 255;           // non signé 8 bits    let c: f64 = 3.1415;       // double précision    let is_rust_cool = true;   // bool    let letter = 'R';          // char (4 octets, Unicode)    let greeting = String::from("Hello, Rust!");    println!("{} {} {} {} {} {}", a, b, c, is_rust_cool, letter, greeting);}

Fonctions

Les fonctions sont déclarées en utilisant le mot-clé fn. Le type de retour est spécifié après la flèche ->.

fn add(x: i32, y: i32) -> i32 {    x + y   // la dernière expression est la valeur de retour (pas de point-virgule)}

fn main() {    let sum = add(10, 20);    println!("10 + 20 = {}", sum);}

3. Concept clé : Propriété et emprunt

Le sujet le plus complexe, mais aussi le plus important en Rust, est le système de propriété. C'est ce qui garantit la sécurité mémoire sans ramasse-miettes.