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 conception | Description |
|---|---|
| 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 nul | Les 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 peur | Le système de types et les règles de propriété éliminent les courses aux données à la compilation |
| Aspect pratique | Permet 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 forte | Le compilateur infère automatiquement la plupart des types, réduisant le code répétitif |
| Chaîne d'outils riche | Cargo (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.
| Temps | Version/Événement | Description |
|---|---|---|
| 2006 | Projet personnel | Graydon Hoare a commencé à concevoir le langage Rust |
| 2009 | Parrainage de Mozilla | Mozilla a officiellement soutenu le développement de Rust et formé une équipe |
| 2010 | Première annonce publique | Première révélation publique du compilateur Rust (écrit en OCaml) lors d'un sommet Mozilla |
| 2011 | Amorçage terminé | Le compilateur Rust a été réécrit en Rust lui-même, éliminant la dépendance à OCaml |
| Mai 2015 | Rust 1.0 | Première version stable publiée, marquant le langage comme officiellement prêt pour une utilisation en production |
| Décembre 2018 | Édition Rust 2018 | Première édition publiée, optimisant la syntaxe et le système de modules (introduction du vérificateur d'emprunts NLL) |
| 2019 | L'écosystème async prend forme | La syntaxe async/await stabilisée, les runtimes async comme Tokio ont mûri |
| 2021 | Création de la Rust Foundation | AWS, Google, Huawei, Microsoft et Mozilla ont conjointement créé la Rust Foundation |
| Octobre 2021 | Édition Rust 2021 | Introduction d'améliorations telles que la capture disjointe et IntoIterator pour les tableaux |
| 2022 | Adopté par le noyau Linux | Linux 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 Rust | Optimisation 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ègle | Description | Signification |
|---|---|---|
| Chaque valeur a exactement un propriétaire | Une 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ée | Lorsqu'une variable quitte sa portée, Rust appelle automatiquement drop pour libérer la mémoire | Pas besoin de gestion manuelle de la mémoire |
| À tout moment : soit une référence mutable, soit plusieurs références immuables | Lecture/é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
// 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
// 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
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
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::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 ».
| Commande | Fonction | Scénario typique |
|---|---|---|
| cargo new project | Créer un nouveau projet | Initialiser un projet, en générant automatiquement Cargo.toml et src/main.rs |
| cargo build | Compiler le projet (mode debug) | Développement et débogage |
| cargo build --release | Compiler le projet (mode optimisé) | Version de production, activation de toutes les optimisations du compilateur |
| cargo run | Compiler et exécuter | Tester rapidement le code |
| cargo test | Exécuter les tests | Tests unitaires, tests d'intégration, tests de documentation |
| cargo check | Vé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 --open | Générer et ouvrir la documentation | Parcourir la documentation API des bibliothèques de dépendances |
| cargo clippy | Vérification du style de code (lint) | Détecter les pratiques déconseillées et les problèmes potentiels |
| cargo fmt | Formatage du code | Unifier le style de code |
| cargo publish | Publier sur crates.io | Publier 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 :
| Outil | Fonction | Remplace |
|---|---|---|
| ripgrep (rg) | Recherche de code ultra-rapide | grep |
| fd | Recherche rapide de fichiers | trouver |
| bat | Visualisation de fichiers avec coloration syntaxique | cat |
| delta | Diff Git avec coloration syntaxique | git diff |
| zoxide | Navigation intelligente dans les répertoires | cd |
| dust | Analyse de l'espace disque | du |
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
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
// 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
// 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égorie | Type | Exemple | Description |
|---|---|---|---|
| Entiers signés | i8, i16, i32, i64, i128, isize | let x: i32 = -42; | Le type entier par défaut est i32 |
| Entiers non signés | u8, u16, u32, u64, u128, usize | let y: u64 = 100; | usize est utilisé pour l'indexation et les longueurs |
| Nombres à virgule flottante | f32, f64 | let pi: f64 = 3.14; | Le type à virgule flottante par défaut est f64 |
| Boolean | bool | let ok: bool = true; | true ou false |
| Caractère | char | let 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 dynamique | Vec<T> | let v: Vec<i32> = vec![1,2,3]; | Longueur variable, alloué sur le tas |
| String | String / &str | let 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
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
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
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
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
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 :
| Commande | Fonction | Description |
|---|---|---|
| rustup update | Mettre à jour la chaîne d'outils Rust | Mettre à niveau rustc, cargo, etc. vers la dernière version stable |
| rustup component add rustfmt | Installer l'outil de formatage de code | Formater automatiquement le code lors de l'enregistrement |
| rustup component add clippy | Installer l'outil d'analyse statique de code | Trouver les modèles de code déconseillés et les bogues potentiels |
| rustup doc | Ouvrir la documentation locale | Consulter la bibliothèque standard et The Book hors ligne |
| cargo add <crate> | Ajouter une dépendance | Modifier automatiquement Cargo.toml et récupérer la dernière version |
| cargo update | Mettre à jour les versions des dépendances | Mettre à jour Cargo.lock selon les contraintes de version dans Cargo.toml |
| cargo tree | Afficher l'arborescence des dépendances | Visualiser l'ensemble des relations de dépendance du projet |
| cargo bench | Lancer des benchmarks | Mesurer les performances du code |
| cargo install <tool> | Installer des outils CLI écrits en Rust | par 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
// 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 :
| Dimension | Performances de Rust |
|---|---|
| Courbe d'apprentissage | Abrupte (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 compilation | Relativement lente (vérifications étendues à la compilation), mais atténuée par cargo check et la compilation incrémentale |
| Performances d'exécution | Au même niveau que C/C++, surpassant de loin les langages avec GC |
| Sécurité mémoire | Garanti à 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ème | Croissance rapide, déjà très mature en programmation système, WebAssembly et blockchain |
| Idéal pour | Programmation système, backends haute performance, WebAssembly, systèmes embarqués, blockchain, outils CLI, bases de données |
| Pas très adapté pour | Prototypage rapide (temps de compilation), applications de bureau GUI, développement de jeux (comparé à des moteurs matures) |