Introduction à Rust

Rust est un langage de programmation système dirigé par Mozilla Research, avecla sécurité mémoire、des abstractions à coût zéroetla concurrence sans peurcomme objectifs de conception fondamentaux.

Rust est né en 2006, d'abord comme projet personnel de Graydon Hoare, employé de Mozilla, puis en 2009 il a été officiellement sponsorisé par Mozilla, qui a formé une équipe pour le développer.

L'objectif de conception initial de Rust était de résoudre les points douloureux de longue date de C/C++ en programmation système :les problèmes de sécurité mémoire(pointeurs nuls, pointeurs pendants, dépassements de tampon) etla complexité de la programmation concurrente(courses aux données, interblocages).

La philosophie de conception de Rust est d'« éliminer les bogues à la compilation »—grâce à un système de types puissant et à un mécanisme de propriété, le compilateur vous aide à détecter les erreurs de mémoire et les courses aux données au lieu de découvrir les problèmes à l'exécution.

La mascotte du langage Rust est un crabe nommé Ferris, sympathique et mignon, représentant la culture amicale et inclusive de la communauté Rust.

Les principaux objectifs de conception de Rust peuvent être résumés comme suit :

Objectif de conceptionDescription
Sécurité mémoire (sans GC)Garantit la sécurité mémoire à la compilation grâce au système de propriété, sans avoir besoin d'un ramasse-miettes
Abstractions à coût nulLes fonctionnalités de haut niveau du langage n'ont aucune surcharge à l'exécution après compilation, égalant les performances du code bas niveau écrit à la main
Concurrence sans peurLe système de types et les règles de propriété éliminent les courses aux données à la compilation
Aspect pratiquePermet d'écrire à la fois des noyaux de systèmes d'exploitation et des applications web, couvrant des scénarios full-stack
Inférence de types forteLe compilateur infère automatiquement la plupart des types, réduisant le code répétitif
Chaîne d'outils richeCargo (gestion de paquets + compilation), rustfmt (formatage), clippy (analyse statique) prêts à l'emploi

Histoire du langage Rust

Rust a connu près de deux décennies de développement, passant d'un projet personnel à un langage système largement adopté dans le monde entier.

TempsVersion/ÉvénementDescription
2006Projet personnelGraydon Hoare a commencé à concevoir le langage Rust
2009Parrainage de MozillaMozilla a officiellement soutenu le développement de Rust et formé une équipe
2010Première annonce publiquePremière révélation publique du compilateur Rust (écrit en OCaml) lors d'un sommet Mozilla
2011Amorçage terminéLe compilateur Rust a été réécrit en Rust lui-même, éliminant la dépendance à OCaml
Mai 2015Rust 1.0Première version stable publiée, marquant le langage comme officiellement prêt pour une utilisation en production
Décembre 2018Édition Rust 2018Première édition publiée, optimisant la syntaxe et le système de modules (introduction du vérificateur d'emprunts NLL)
2019L'écosystème async prend formeLa syntaxe async/await stabilisée, les runtimes async comme Tokio ont mûri
2021Création de la Rust FoundationAWS, Google, Huawei, Microsoft et Mozilla ont conjointement créé la Rust Foundation
Octobre 2021Édition Rust 2021Introduction d'améliorations telles que la capture disjointe et IntoIterator pour les tableaux
2022Adopté par le noyau LinuxLinux 6.1 a officiellement intégré le support de Rust, faisant de Rust le deuxième langage pour le développement du noyau
février 2024Édition 2024 de RustOptimisation accrue de la cohérence du langage et de l'expérience développeur

La fondation de la Rust Foundation en 2021 a été un jalon. Cinq géants de la tech — AWS, Google, Huawei, Microsoft et Mozilla — se sont engagés conjointement à garantir le développement indépendant à long terme de Rust, apaisant les inquiétudes de la communauté concernant « la domination par une seule entreprise ».

Rust adopteune version stable toutes les six semainescomme rythme de publication, tout en utilisant le mécanisme d'Édition(publié environ tous les 3 ans) pour gérer les changements de langage incompatibles. Un seul projet peut mélanger des crates de différentes Éditions, et le compilateur garantit la rétrocompatibilité.


Fonctionnalités principales du langage Rust

L'ensemble des fonctionnalités de Rust s'articule autour de trois dimensions : « sûr, efficace, pratique ». Ci-dessous, nous décomposons les fonctionnalités les plus essentielles du langage Rust une par une.

Système de propriété

La propriété est la caractéristique la plus unique et la plus importante de Rust. Elle gère la mémoire au moment de la compilation, sans ramasse-miettes ni malloc/free manuel.

La propriété a trois règles principales :

RègleDescriptionSignification
Chaque valeur a exactement un propriétaireUne valeur ne peut être possédée que par une seule variable à la foisÉlimine les doubles libérations et les pointeurs pendants
Lorsque le propriétaire quitte la portée, la valeur est libéréeLorsqu'une variable quitte sa portée, Rust appelle automatiquement drop pour libérer la mémoirePas besoin de gestion manuelle de la mémoire
À tout moment : soit une référence mutable, soit plusieurs références immuablesLecture/écriture mutuellement exclusives, coexistence lecture/lectureÉlimine les courses de données à la compilation

L'expérience intuitive au niveau du code : lorsqu'une variable est affectée à une autre variable, la propriété est transférée (move), et la variable d'origine devient invalide.

Exemple

fn main() {
    // s1 acquiert la propriété de la chaîne (données stockées sur le tas)
    let s1 = String::from("Hello, EXAMPLE!");

    // La propriété est transférée de s1 à s2 ; après cela, s1 n'est plus valide
    let s2 = s1;

    // println!("{}", s1); // Erreur de compilation ! s1 a été déplacé
    println!("{}", s2);    // Correct : s2 est maintenant le propriétaire

    // Les types de base (stockés sur la pile) implémentent le trait Copy, donc aucun déplacement ne se produit
    let x = 42;
    let y = x;  // x est toujours valide car i32 implémente Copy
    println!("x = {}, y = {}", x, y); // Les deux peuvent être utilisés

    // Références immuables : plusieurs peuvent exister en même temps
    let s3 = &s2; // Emprunt immuable
    let s4 = &s2; // Un autre emprunt immuable, autorisé
    println!("s3 = {}, s4 = {}", s3, s4);

    // Référence mutable : une seule peut exister à la fois
    let mut data = String::from("example");
    let r = &mut data; // Emprunt mutable
    r.push_str("!");   // Modifier la valeur d'origine via une référence mutable
    println!("Après modification : {}", r);
    // Les portées de s3 et s4 ont pris fin, donc des références mutables peuvent être créées
}

Le système de propriété est une « pente raide » dans la courbe d'apprentissage de Rust. Les débutants « se battent » souvent avec le compilateur, mais une fois compris, vous découvrirez que les erreurs détectées par le compilateur pourraient être des bugs d'exécution fatals en C/C++.

Filtrage par motifs

Les expressionsmatchde Rust sont extrêmement puissantes ; le compilateur vavérifier de manière exhaustivetous les cas, garantissant qu'aucune branche n'est oubliée.

Exemple

fn main() {
    // match avec correspondance numérique
    let score = 85;
    match score {
        90..=100 => println!("EXAMPLE Rating: A"), // Correspondance par plage
        60..=89  => println!("EXAMPLE Rating: B"),
        0..=59   => println!("EXAMPLE Rating: C"),
        _ => println!("Invalid score"),                // Joker, correspond à tous les cas restants
    }

    // match déstructurant un tuple
    let pair = (3, 7);
    match pair {
        (0, y) => println!("Le premier est 0, le second est {}", y),
        (x, 0) => println!("Le premier est {}, le second est 0", x),
        (x, y) => println!("Deux valeurs : {} et {}", x, y),
    }
}

Énumérations et Option/Result

Les énumérations de Rust peuvent porter des données et, combinées à match, elles permettent un flux de contrôle sûr et expressif.

Dans la bibliothèque standard,Option<T>etResult<T, E>sont les deux types d'énumération les plus fondamentaux, gérant respectivement les scénarios « possiblement absent » et « possiblement erroné » — Rust n'a ni null ni exceptions.

Exemple

use std::fs;

fn main() {
    // Option<T> : une valeur peut être présente ou non (remplace null)
    let numbers = vec![10, 20, 30];
    let first = numbers.get(0);   // Renvoie Option<&i32>
    let missing = numbers.get(5); // Renvoie Option<&i32>

    match first {
        Some(&val) => println!("Premier élément : {}", val),
        None => println!("Non trouvé"),
    }

    // Manière plus concise : if let
    if let Some(&val) = missing {
        println!("Trouvé : {}", val);
    } else {
        println!("L'index 5 n'existe pas");  // Cette branche est attendue
    }

    // Result<T, E> : une opération peut réussir ou échouer (remplace les exceptions)
    let content = fs::read_to_string("config.txt");
    match content {
        Ok(text) => println!("Contenu du fichier : {}", text),
        Err(e) => println!("Échec de la lecture : {}", e),
    }
}

Rust n'a pas de valeurs null et pas de mécanisme d'exception try-catch. Option et Result sont imposés à la compilation—si vous oubliez de vérifier, le code ne compilera pas. Cela élimine fondamentalement les exceptions de pointeur null et les exceptions non interceptées.

Abstractions à coût nul

Les fonctionnalités de haut niveau de Rust (itérateurs, fermetures, génériques) sont complètement équivalentes à des boucles de bas niveau écrites à la main après compilation, sans surcoût d'exécution supplémentaire.

Cela signifie que vous pouvez écrire du code dans un style fonctionnel tout en atteignant des performances aussi élevées que C.

Exemple

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // Chaînage d'itérateurs — ressemble à une abstraction de haut niveau
    // Se développe après compilation en code machine équivalent à une boucle for écrite à la main
    let result: Vec<i32> = data
        .iter()            // Obtenir un itérateur
        .filter(|&x| x % 2 == 0) // Filtrer les nombres pairs
        .map(|&x| x * x)         // Élever au carré
        .collect();              // Collecter dans un Vec

    println!("{:?}", result); // [4, 16, 36, 64, 100]
}

Concurrence sans peur

Le système de types et les règles de propriété de Rustà la compilationéliminent les courses de données. Les traits Send et Sync indiquent automatiquement si un type peut être transféré ou partagé en toute sécurité entre threads.

Si vous essayez de partager des données non thread-safe entre threads, le compilateur signalera directement une erreur — plutôt que d'attendre que d'étranges bogues de concurrence apparaissent en production à l'exécution.

Exemple

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc (comptage atomique de références) est utilisé pour partager la propriété entre les threads
    // Mutex fournit un accès mutuellement exclusif
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for i in 0..10 {
        // Clone Arc afin que chaque thread détienne une référence aux mêmes données
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // lock() acquiert le mutex et renvoie MutexGuard
            let mut num = counter.lock().unwrap();
            *num += 1; // Modifier la valeur interne par déréférencement
            println!("Le thread {} a fini d'accumuler, valeur actuelle : {}", i, *num);
        });
        handles.push(handle);
    }

    // Attendre que tous les threads se terminent
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Compte final : {}", *counter.lock().unwrap());
}

Cargo : outil de compilation tout-en-un

Cargo est le gestionnaire de paquets et système de compilation officiel de Rust, intégrant la gestion des dépendances, la compilation, les tests, la génération de documentation et la publication.

Comparé à l'expérience fragmentée de l'écosystème C/C++, qui exige une configuration manuelle de CMake/Makefile et des gestionnaires de paquets, Cargo offre une expérience tout-en-un « prête à l'emploi ».

CommandeFonctionScénario typique
cargo new projectCréer un nouveau projetInitialiser un projet, en générant automatiquement Cargo.toml et src/main.rs
cargo buildCompiler le projet (mode debug)Développement et débogage
cargo build --releaseCompiler le projet (mode optimisé)Version de production, activation de toutes les optimisations du compilateur
cargo runCompiler et exécuterTester rapidement le code
cargo testExécuter les testsTests unitaires, tests d'intégration, tests de documentation
cargo checkVérifier rapidement si le code se compile (sans générer de binaire)Vérification syntaxique en temps réel dans les IDE
cargo doc --openGénérer et ouvrir la documentationParcourir la documentation API des bibliothèques de dépendances
cargo clippyVérification du style de code (lint)Détecter les pratiques déconseillées et les problèmes potentiels
cargo fmtFormatage du codeUnifier le style de code
cargo publishPublier sur crates.ioPublier une bibliothèque open source

cargo check est une commande très utile pendant le développement. Elle vérifie uniquement la syntaxe et les types et ne génère pas d'exécutable, elle est donc bien plus rapide que cargo build. La plupart des plugins Rust des IDE exécutent automatiquement cargo check lors de l'enregistrement des fichiers.


Domaines d'application du langage Rust

Avec sa sécurité mémoire et ses hautes performances, Rust s'étend rapidement dans de multiples domaines.

Programmation système et serveurs hautes performances

C'est le « terrain de prédilection » de Rust — adapté aux scénarios exigeant des performances extrêmes et une grande sécurité mémoire. Le runtime asynchroneTokioet les frameworks webActix Web、Axumexcellent dans les scénarios à forte concurrence.

WebAssembly

Rust estl'un des meilleurs langages pour compiler vers WebAssembly. Ses abstractions à coût nul et son absence de GC rendent les artefacts Wasm petits et très performants.

Frameworks frontendYewetLeptospermettent d'écrire des applications SPA en Rust. Figma, Cloudflare Workers, etc. utilisent massivement Rust + Wasm en production.

Embarqué et IoT

Le modeno_stdde Rust permet de fonctionner sur du bare metal sans système d'exploitation, adapté aux appareils aux ressources limitées comme les MCU et les capteurs.

RTIC(framework de concurrence temps réel piloté par interruptions) etEmbassy(framework embarqué asynchrone) sont des projets représentatifs de Rust embarqué.

Outils CLI

Rust se compile en binaires autonomes avec d'excellentes performances, produisant de nombreux outils CLI phares :

OutilFonctionRemplace
ripgrep (rg)Recherche de code ultra-rapidegrep
fdRecherche rapide de fichierstrouver
batVisualisation de fichiers avec coloration syntaxiquecat
deltaDiff Git avec coloration syntaxiquegit diff
zoxideNavigation intelligente dans les répertoirescd
dustAnalyse de l'espace disquedu

Blockchain et Web3

Rust occupe une place importante dans le domaine de la blockchain.SolanaLe cœur de la chaîne est écrit en Rust,Sui、Aptos、Polkadot(Substrate)et d'autres nouvelles chaînes publiques utilisent également Rust comme principal langage de développement.

Bases de données et infrastructure de données

Les bases de données et les systèmes de traitement de données hautes performances sont des domaines de prédilection de Rust :TiKV(stockage KV distribué, couche de stockage de TiDB),SurrealDB、Polars(bibliothèque DataFrame),Databend(entrepôt de données cloud), etc., sont tous construits avec Rust.

Systèmes d'exploitation et infrastructure

Rust a intégré le noyau Linux (6.1+). Google réécrit les piles Bluetooth et Wi-Fi avec Rust dans Android, et Microsoft réécrit également certains composants du noyau Windows en utilisant Rust.

Pour les projets personnels,Redox OSest un système d'exploitation de type Unix entièrement écrit à partir de zéro en Rust.


Démarrage rapide

Rust fournit officiellement un outil d'installation extrêmement pratique, rustup, qui gère le compilateur, le gestionnaire de paquets et la documentation avec une seule commande.

Installer Rust

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

# 验证安装
$ rustc --version
rustc 1.85.0 (4d91de4e4 2025-02-17)

$ cargo --version
cargo 1.85.0

Votre premier programme Rust

Utiliser Cargo pour créer un projet est l'approche la plus recommandée ; elle génère automatiquement une structure de projet standard.

# 创建新项目
$ cargo new hello_example
     Created binary (application) `hello_example` package

# 项目结构
hello_example/
├── Cargo.toml     # 项目元数据和依赖配置
└── src/
    └── main.rs    # 程序入口文件

Cargo.toml est le fichier de configuration du projet, similaire au package.json de Node.js :

Exemple

[package]
name = "hello_example"           # Nom du paquet (obligatoire, séparé par des traits de soulignement)
version = "0.1.0"               # Numéro de version (obligatoire, suit le versionnage sémantique)
edition = "2024"                # Édition Rust (obligatoire, affecte les règles de syntaxe du langage)

[dependencies]
# Déclarez les dépendances du projet ici, par exemple :
# serde = { version = "1.0", features = ["derive"] }

Le fichier main.rs généré contient par défaut un simple programme Hello World :

Exemple

// Chemin du fichier : src/main.rs
// Point d'entrée du programme Rust : chaque programme exécutable doit avoir une fonction main

fn main() {
    // println! est une macro (notez le symbole ! qui le suit)
    // Les macros se développent en un code plus complexe au moment de la compilation
    println!("Hello, EXAMPLE!");
    println!("Welcome to the world of the Rust language");
}
# 编译并运行
$ cargo run
   Compiling hello_example v0.1.0
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
     Running `target/debug/hello_example`
Hello, EXAMPLE!
欢迎来到 Rust 语言的世界

Aperçu de la syntaxe de base

La syntaxe de Rust emprunte les points forts des langages fonctionnels et des langages système. Ce qui suit est un aperçu rapide des éléments de syntaxe les plus couramment utilisés ; chaque exemple est un programme complet pouvant être exécuté directement.

Variables et mutabilité

Variables en RustImmuables par défaut(immuable). Cela force les développeurs à marquer explicitement quelles données peuvent changer, ce qui rend l'intention du code plus claire et facilite l'optimisation par le compilateur.

Exemple

fn main() {
    // Variable immuable (par défaut) : ne peut pas être réaffectée après la déclaration
    let name = "EXAMPLE";
    // name = "other"; // Erreur de compilation ! Les variables immuables ne peuvent pas être réaffectées
    println!("Name: {}", name);

    // Variable mutable : déclarée explicitement avec le mot-clé mut
    let mut score = 0;
    println!("Initial score: {}", score);
    score = 100;       // Peut être modifié
    println!("Score mis à jour : {}", score);

    // Masquage de variable : redéclarer une variable avec le même nom en utilisant let
    let x = 5;
    let x = x + 1;      // La nouvelle variable x masque l'ancienne x, avec une valeur de 6
    let x = x * 2;      // Masquée à nouveau, avec une valeur de 12
    println!("Valeur finale de x : {}", x);

    // Constante : déterminée à la compilation, le type doit être annoté, la convention de nommage utilise tout en majuscules
    const MAX_POINTS: u32 = 100_000;
    println!("Points maximum : {}", MAX_POINTS);
}

Le masquage de variable n'est pas la même chose que mut. Le masquage utilise let pour redéclarer une nouvelle variable avec le même nom, ce qui peut changer le type ; mut permet simplement de modifier la valeur de la même variable, sans que le type change.

Types de données de base

Rust est un langage à typage statique ; le compilateur doit connaître le type de chaque variable au moment de la compilation.

CatégorieTypeExempleDescription
Entiers signési8, i16, i32, i64, i128, isizelet x: i32 = -42;Le type entier par défaut est i32
Entiers non signésu8, u16, u32, u64, u128, usizelet y: u64 = 100;usize est utilisé pour l'indexation et les longueurs
Nombres à virgule flottantef32, f64let pi: f64 = 3.14;Le type à virgule flottante par défaut est f64
Booleanboollet ok: bool = true;true ou false
Caractèrecharlet c = 'R';4 octets, représentant une valeur scalaire Unicode
Tuple(T1, T2, ...)let t: (i32, f64) = (10, 3.14);Longueur fixe, les éléments peuvent avoir différents types
Tableau[T; N]let a: [i32; 3] = [1, 2, 3];Longueur fixe, même type, alloué sur la pile
Tranche&[T]let s: &[i32] = &a[..];Une vue de référence sur un tableau ou un Vec
Tableau dynamiqueVec<T>let v: Vec<i32> = vec![1,2,3];Longueur variable, alloué sur le tas
StringString / &strlet s = String::from("hi");String est mutable, &str est une référence

Flux de contrôle

Le flux de contrôle de Rust inclutif、loop、while、foretmatch. Parmi ceux-ci, if et loop peuvent renvoyer des valeurs en tant qu'expressions.

Exemple

fn main() {
    let score = 75;

    // if est une expression et peut renvoyer une valeur (toutes les branches doivent renvoyer le même type)
    let grade = if score >= 90 {
        "A"
    } else if score >= 60 {
        "B"
    } else {
        "C"
    };
    println!("EXEMPLE note: {}", grade);

    // loop est une boucle infinie (on en sort avec break, peut renvoyer une valeur)
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 2; // break suivi d'une valeur agit comme la valeur de retour de la boucle
        }
    };
    println!("valeur de retour de la boucle: {}", result);

    // boucle conditionnelle while
    let mut n = 3;
    while n > 0 {
        println!("Compte à rebours : {}", n);
        n -= 1;
    }

    // itération for in (la plus couramment utilisée)
    let items = ["pomme", "banane", "cerise"];
    for (i, item) in items.iter().enumerate() {
        println!("Élément {} : {}", i + 1, item);
    }

    // itération for in sur une plage
    for num in 1..=3 { // 1..=3 représente 1, 2, 3 (bornes incluses)
        println!("Nombre : {}", num);
    }
}

Fonctions

Les fonctions Rust utilisent le mot-cléfnpour se déclarer, et les paramètres et valeurs de retour doivent être explicitement annotés avec leurs types. La valeur de la dernière expression est la valeur de retour (aucun mot-clé return n'est nécessaire).

Exemple

// Fonction ordinaire : prend deux i32, renvoie leur somme
fn add(a: i32, b: i32) -> i32 {
    a + b  // La dernière expression est automatiquement utilisée comme valeur de retour (notez qu'il n'y a pas de point-virgule à la fin)
}

// Plusieurs valeurs de retour : utiliser un tuple pour renvoyer plusieurs valeurs
fn divide(a: f64, b: f64) -> (f64, String) {
    if b == 0.0 {
        return (0.0, String::from("Erreur : le diviseur ne peut pas être zéro"));
    }
    (a / b, String::from("OK")) // Renvoie un tuple
}

// Fonction générique : utilise des bornes de trait pour contraindre le comportement des paramètres de type
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn main() {
    // Appel d'une fonction ordinaire
    let sum = add(10, 20);
    println!("10 + 20 = {}", sum);

    // Appel de la fonction à valeurs de retour multiples
    let (result, msg) = divide(10.0, 2.0);
    println!("10 / 2 = {} ({})", result, msg);

    // Cas de division par zéro
    let (result, msg) = divide(10.0, 0.0);
    println!("10 / 0 = {} ({})", result, msg);

    // Appel d'une fonction générique
    let nums = vec![3, 7, 2, 9, 5];
    println!("EXEMPLE nombre maximum: {}", largest(&nums));
}

Structures et blocs impl

Rust utilisestructpour définir des structures de données, et utilise des blocsimplpour implémenter des méthodes pour les structures. Cela est similaire au style de définition de méthodes de Go, mais l'organisation du langage est plus compacte.

Exemple

// Définit une structure (similaire à la struct de C, mais plus puissante)
struct User {
    name: String,         // Type String, possède les données
    email: String,
    active: bool,
    login_count: u64,     // u64 est un entier non signé 64 bits
}

// le bloc impl implémente des méthodes pour User
impl User {
    // Fonction associée (comme une méthode statique) : crée une nouvelle instance
    fn new(name: String, email: String) -> Utilisateur {
        Utilisateur {
            name,
            email,
            active: true,     // Valeur par défaut
            login_count: 0,   // Valeur par défaut
        }
    }

    // Méthode : &self représente une référence immuable à l'instance
    fn summary(&self) -> String {
        format!("{} ({}) - Nombre de connexions : {}", self.name, self.email, self.login_count)
    }

    // Méthode : &mut self représente une référence mutable à l'instance
    fn login(&mut self) {
        self.login_count += 1;
    }
}

fn main() {
    // Crée une instance à l'aide d'une fonction associée
    let mut user = User::new(
        String::from("example"),
        String::from("example@example.com"),
    );

    println!("{}", user.summary());

    // Simule la connexion
    user.login();
    user.login();
    println!("Logged in {} times", user.login_count);
}

Exemples courants

Les deux exemples complets suivants, proches de scénarios réels, démontrent des utilisations typiques de Rust dans le développement réel.

Création d'un service d'API HTTP

Utilisez le framework Axum (basé sur le runtime asynchrone Tokio) pour construire une API HTTP avec des réponses JSON.

Tout d'abord, ajoutez les dépendances à Cargo.toml :

# Cargo.toml
[dependencies]
axum = "0.8"              # Web 框架
tokio = { version = "1", features = ["full"] }  # 异步运行时
serde = { version = "1", features = ["derive"] } # 序列化
serde_json = "1"           # JSON 支持

Exemple

// Chemin du fichier : src/main.rs
use axum::{
    extract::Query,
    response::Json,
    routing::get,
    Router,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// Structure de paramètres de requête (désérialisation)
#[derive(Deserialize)]
struct HelloParams {
    name: Option<String>, // Option indique un paramètre optionnel
}

// Structure de réponse (sérialisation)
#[derive(Serialize)]
struct ApiResponse {
    code: u16,
    message: String,
    data: Option<HashMap<String, String>>, // Champ de données facultatif
}

// Gère les requêtes GET /hello
// Query(HelloParams) extrait automatiquement le nom à partir des paramètres de requête d'URL
async fn hello_handler(Query(params): Query<HelloParams>) -> Json<ApiResponse> {
    let name = params.name.unwrap_or_else(|| String::from("EXAMPLE"));

    let mut data = HashMap::new();
    data.insert("name".to_string(), name.clone());

    Json(ApiResponse {
        code: 200,
        message: format!("Bonjour, {} ! Bienvenue dans le service HTTP Rust", name),
        data: Some(data),
    })
}

// La macro #[tokio::main] convertit async fn main en un runtime Tokio
#[tokio::main]
async fn main() {
    // Construction du routeur
    let app = Router::new()
        .route("/hello", get(hello_handler));

    // Lie l'adresse et démarre le service
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
        .await
        .unwrap();

    println!("EXAMPLE serveur démarré, en écoute sur : http://localhost:8080");
    println!("Exemple d'accès : http://localhost:8080/hello?name=Rust开发者");

    axum::serve(listener, app).await.unwrap();
}
$ cargo run
EXAMPLE 服务器启动,监听地址: http://localhost:8080
访问示例: http://localhost:8080/hello?name=Rust开发者

# 使用 curl 测试
$ curl http://localhost:8080/hello?name=Rust开发者
{"code":200,"message":"你好,Rust开发者!欢迎访问 Rust HTTP 服务","data":{"name":"Rust开发者"}}

$ curl http://localhost:8080/hello
{"code":200,"message":"你好,EXAMPLE!欢迎访问 Rust HTTP 服务","data":{"name":"EXAMPLE"}}

Axum est l'un des frameworks web les plus populaires de l'écosystème Rust, maintenu par l'équipe Tokio. Il exploite pleinement le système de types de Rust pour vérifier des opérations telles que l'extraction des paramètres de route et le partage d'état au moment de la compilation, ce qui réduit considérablement les erreurs d'exécution.

Outil de traitement par lots de fichiers

Ceci est un outil CLI proche de scénarios réels : il parcourt récursivement les répertoires, compte le nombre de lignes et les tailles de tous les fichiers, et les agrège par extension.

Ajoutez les dépendances à Cargo.toml :

# Cargo.toml
[dependencies]
walkdir = "2"  # 递归遍历目录

Exemple

// Chemin du fichier : src/main.rs
use std::collections::HashMap;
use std::fs;
use walkdir::WalkDir; // Bibliothèque tierce pour parcourir récursivement les répertoires

fn main() {
    let path = "."; // Analyse à partir du répertoire courant

    // Statistiques : regroupées par extension de fichier
    // HashMap<extension, (nombre de fichiers, total de lignes, total d'octets)>
    let mut stats: HashMap<String, (usize, usize, u64)> = HashMap::new();

    // WalkDir parcourt récursivement les répertoires, en ignorant automatiquement les fichiers cachés et le répertoire .git
    for entry in WalkDir::new(path)
        .into_iter()
        .filter_map(|e| e.ok()) // Filtre les entrées inaccessibles
        .filter(|e| e.file_type().is_file()) // Ne traiter que les fichiers
    {
        // Obtenir l'extension du fichier
        let ext = entry
            .path()
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("(aucune extension)")
            .to_lowercase();

        // Lire le contenu du fichier (fichiers texte uniquement ; les fichiers binaires peuvent afficher du texte illisible mais cela n'affectera pas les statistiques)
        if let Ok(content) = fs::read_to_string(entry.path()) {
            let line_count = content.lines().count();
            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);

            let (count, lines, total_size) = stats.entry(ext).or_insert((0, 0, 0));
            *count += 1;
            *lines += line_count;
            *total_size += size;
        }
    }

    // Trier par nombre de fichiers par ordre décroissant et afficher
    let mut sorted: Vec<_> = stats.into_iter().collect();
    sorted.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));

    println!("=== Statistiques de fichiers du répertoire EXAMPLE ===");
    println!("{:<15} {:>8} {:>10} {:>12}", "Extension", "Nombre de fichiers", "Lignes totales", "Taille totale (bytes)");
    println!("{}", "-".repeat(50));
    for (ext, (count, lines, size)) in &sorted {
        println!("{:<15} {:>8} {:>10} {:>12}", ext, count, lines, size);
    }
}
$ cargo run --release
=== EXAMPLE 目录文件统计 ===
扩展名            文件数       总行数   总大小(bytes)
--------------------------------------------------
rs                  12        856        28432
toml                 3         45         1534
md                   2        120         3412
html                 1        510        14256
(无扩展名)            1          8          210

Outils courants et référence des commandes

Outre les fonctionnalités intégrées de Cargo, l'écosystème Rust fournit une série d'outils pour améliorer l'efficacité du développement :

CommandeFonctionDescription
rustup updateMettre à jour la chaîne d'outils RustMettre à niveau rustc, cargo, etc. vers la dernière version stable
rustup component add rustfmtInstaller l'outil de formatage de codeFormater automatiquement le code lors de l'enregistrement
rustup component add clippyInstaller l'outil d'analyse statique de codeTrouver les modèles de code déconseillés et les bogues potentiels
rustup docOuvrir la documentation localeConsulter la bibliothèque standard et The Book hors ligne
cargo add <crate>Ajouter une dépendanceModifier automatiquement Cargo.toml et récupérer la dernière version
cargo updateMettre à jour les versions des dépendancesMettre à jour Cargo.lock selon les contraintes de version dans Cargo.toml
cargo treeAfficher l'arborescence des dépendancesVisualiser l'ensemble des relations de dépendance du projet
cargo benchLancer des benchmarksMesurer les performances du code
cargo install <tool>Installer des outils CLI écrits en Rustpar ex., cargo install ripgrep

Notes et problèmes courants

Voici les défis que les débutants en Rust rencontrent le plus facilement, ainsi que les recommandations de bonnes pratiques.

Il est normal de se battre avec le compilateur

La courbe d'apprentissage de Rust est largement reconnue comme abrupte au début et plus douce par la suite.La propriété et la vérification des empruntsconstituent le plus grand obstacle lorsqu'on débute.

Lorsque le compilateur rejette de façon répétée le code que vous écrivez, ne vous découragez pas — cela montre précisément que le compilateur vous aide à détecter des bugs d'exécution potentiels. Au fur et à mesure que vous acquérez de l'expérience, vous vous habituerez progressivement à penser en Rust, et le compilateur deviendra votre partenaire le plus fiable plutôt qu'un ennemi.

La différence entre String et &str

C'est le concept que les débutants en Rust confondent le plus facilement.Stringest une chaîne possédée allouée sur le tas (modifiable),&strest une référence immuable vers des données de chaîne (une vue empruntée), généralement issue du déréférencement automatique de &String.

Exemple

fn main() {
    // String : possède les données, modifiable, sur le tas
    let mut s = String::from("Hello");

    // &str : référence, immuable, généralement utilisée comme paramètre de fonction
    let slice: &str = "EXAMPLE"; // Les littéraux de chaîne sont eux-mêmes des &str

    s.push_str(", world!"); // String peut être modifiée
    println!("{}", s);
    println!("{}", slice);

    // Utiliser &str (plutôt que String) pour les paramètres de fonction est plus flexible
    greet("EXAMPLE");          // On peut passer &str directement
    greet(&s);                // Peut aussi être automatiquement converti de &String en &str
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

Gestion des erreurs : panic! vs Result

Rust distingueles erreurs irrécupérables(en utilisantpanic!, le programme se termine) etles erreurs récupérables(en utilisantResult, l'appelant décide comment les traiter).

Dans le code de bibliothèque, vous devriez renvoyer Result plutôt que panic!, en laissant le choix à l'appelant. Dans les applications, vous pouvez décider en fonction de la situation spécifique.

unsafe : à utiliser avec prudence, mais nécessaire

Rust fournit le mot-cléunsafe, qui permet des opérations de bas niveau telles que la manipulation de pointeurs bruts et l'appel de fonctions externes (FFI).

unsafe ne signifie pas « désactiver les contrôles de sécurité » ; cela rend plutôt les développeurs responsables de la partie de la sécurité que le compilateur ne peut pas garantir automatiquement. La plupart du code applicatif n'a pas besoin d'utiliser unsafe — si vous constatez que vous l'utilisez fréquemment, cela peut être le signe que votre conception doit être ajustée.

Temps de compilation longs

Rust est connu pour ses longs temps de compilation, en particulier pour les grands projets. Cela s'explique par le fait que le compilateur effectue de nombreuses vérifications (analyse de propriété, validation des durées de vie, résolution des traits, etc.) et optimisations au moment de la compilation.

Mesures d'atténuation : utilisezcargo checkau lieu de cargo build pour le développement quotidien ; divisez les gros crates en sous-crates pour tirer parti de la compilation incrémentale ; utilisezsccachepour mettre en cache les résultats de compilation ; améliorez le matériel (en particulier SSD et plus de cœurs CPU).

Suggestions de parcours d'apprentissage

Pour les débutants en Rust, l'ordre d'apprentissage suivant est recommandé :

  • Lisez en entierThe Rust Programming Language(le livre officiel, gratuit), en vous concentrant sur les chapitres consacrés à la propriété
  • Lisez et écrivez du code dans le Rust Playground (play.rust-lang.org) pour obtenir un retour immédiat du compilateur
  • Grâce àRustlings, faites de petits exercices pour renforcer la syntaxe
  • LisezRust by Example, apprenez par l'exemple
  • Essayez de réécrire en Rust un petit projet que vous connaissez pour comprendre les compromis de conception de Rust en pratique

Résumé

Avec sessécurité mémoire (sans GC)、abstractions à coût nuletconcurrence sans peurtrois avantages fondamentaux, Rust occupe une niche unique dans des domaines tels que la programmation système, les services hautes performances, WebAssembly et la blockchain.

Bien que la courbe d'apprentissage soit abrupte, les vérifications strictes du compilateur se traduisent par une qualité de code et une maintenabilité extrêmement élevées dans les projets à long terme — c'est pourquoi de plus en plus d'entreprises et de projets open source choisissent Rust.

Les avantages de Rust et les cas d'utilisation appropriés sont résumés comme suit :

DimensionPerformances de Rust
Courbe d'apprentissageAbrupte (le système de propriété nécessite compréhension et adaptation), mais les concepts sont stables ; une fois appris, vous en bénéficiez à vie
Vitesse de compilationRelativement lente (vérifications étendues à la compilation), mais atténuée par cargo check et la compilation incrémentale
Performances d'exécutionAu même niveau que C/C++, surpassant de loin les langages avec GC
Sécurité mémoireGaranti à la compilation, pas besoin de GC, pas de pointeurs nuls, de pointeurs suspendus ni de dépassements de tampon
Sécurité de la concurrenceÉlimine les courses de données à la compilation, concurrence sans peur
Maturité de l'écosystèmeCroissance rapide, déjà très mature en programmation système, WebAssembly et blockchain
Idéal pourProgrammation système, backends haute performance, WebAssembly, systèmes embarqués, blockchain, outils CLI, bases de données
Pas très adapté pourPrototypage rapide (temps de compilation), applications de bureau GUI, développement de jeux (comparé à des moteurs matures)
Autres extensions