Fermetures Rust
Une fermeture en Rust est une fonction anonyme qui peut capturer et stocker des variables de son environnement.
Les fermetures permettent d'accéder à des variables en dehors de la portée dans laquelle elles sont définies, et peuvent les déplacer ou les emprunter dans la fermeture lorsque c'est nécessaire.
Les fermetures sont largement utilisées en Rust dans des domaines tels que la programmation fonctionnelle, la programmation concurrente et la programmation événementielle.
Différence entre les fermetures et les fonctions
Les fermetures et les fonctions ordinaires peuvent toutes deux encapsuler une partie de logique, mais les fermetures possèdent une capacité essentielle supplémentaire : capturer des variables de l'environnement externe. Le tableau suivant liste les principales différences entre les deux :
| Fonctionnalité | Fermeture | Fonction |
|---|---|---|
| Anonymat | Pas de nom ; généralement assigné à une variable | A un nom fixefnname |
| Capture de l'environnement | Peut capturer des variables externes | Ne peut pas capturer des variables externes |
| Syntaxe de définition | |paramètres| expression | fn nom(paramètres) |
| Inférence de type | Les types de paramètre et de retour peuvent généralement être omis | Doit spécifier explicitement les types de paramètre et de retour |
| Stockage et passage | Peut servir de variable, paramètre ou valeur de retour | Également pris en charge |
Déclaration et appel de fermetures
La syntaxe de base d'une fermeture est la suivante :
let closure_name = |参数列表| 表达式或语句块;
Les paramètres peuvent avoir des annotations de type, ou elles peuvent être omises — le compilateur Rust les infère à partir du contexte.
Exemple
// Fermeture : annotations de type omises, le compilateur les infère automatiquement
let add_one = |x| x + 1;
println!("add_one(4) = {}", add_one(4)); // Sortie : 5
// Fermeture : annoter explicitement les types de paramètre et de retour
let multiply = |a: i32, b: i32| -> i32 { a * b };
println!("multiply(3, 7) = {}", multiply(3, 7)); // Sortie : 21
// Une fermeture multiligne nécessite des accolades
let greet = |name: &str| {
let greeting = format!("Hello, {}!", name);
greeting
};
println!("{}", greet("example")); // Sortie : Hello, example!
}
Les fermetures sont appelées exactement de la même manière que les fonctions ordinaires : ajoutez des parenthèses après le nom de la variable et passez les arguments.
Capture des variables externes
La caractéristique la plus essentielle d'une fermeture est sa capacité à capturer des variables depuis la portée dans laquelle elle est définie. C'est la différence fondamentale entre les fermetures et les fonctions ordinaires.
Les fermetures peuvent capturer des variables externes de trois manières :
| Méthode de capture | Sémantique Rust correspondante | Description |
|---|---|---|
| Capture par référence | Similaire à&T | Comportement par défaut ; la closure emprunte la variable, et elle reste utilisable à l'extérieur |
| Capture par emprunt mutable | Similaire à&mut T | La closure doit modifier la variable ; la closure elle-même doit être déclarée commemut |
| Capture par valeur | Similaire àT | Utilisermovemot-clé, en déplaçant la propriété de la variable dans la closure |
Pour les types qui implémentent
Copyle trait (commei32、bool),moveseule une copie de la valeur est effectuée, et la variable externe reste utilisable. Par conséquent, pour démontrer le transfert de propriété, choisissezString、Vecet d'autres non-Copytypes.
Capture par référence
Par défaut, une fermeture emprunte les variables externes par référence immuable. Une fois l'emprunt terminé, la portée externe peut continuer à utiliser la variable.
Exemple
let text = String::from("example");
// La fermeture capture text par référence et ne prend pas possession de text
let print_text = || println!("text = {}", text);
print_text(); // Sortie : text = example
// L'emprunt est terminé ; text peut encore être utilisé à l'extérieur
println!("Still usable outside: {}", text);
}
Capture par emprunt mutable
Si une fermeture doit modifier une variable capturée, Rust la capture par référence mutable. Dans ce cas, la fermeture elle-même doit être déclarée commemut。
Exemple
let mut counter = 0;
// La fermeture capture counter par &mut ; la fermeture elle-même doit également être déclarée comme mut
let mut inc = || {
counter += 1;
};
inc();
inc();
println!("counter = {}", counter); // Sortie : counter = 2
}
Capture par valeur (move)
En ajoutant lemovemot-clé avant la fermeture, la fermeture prend possession des variables capturées. Une fois la propriété transférée, la portée externe ne peut plus utiliser la variable.
Exemple
let owned = String::from("EXAMPLE");
// move transfère la propriété de owned à la fermeture
let take_owned = move || println!("owned = {}", owned);
take_owned(); // Sortie : owned = EXAMPLE
// Si vous décommentez la ligne ci-dessous, la compilation échouera : la propriété de owned a été déplacée dans la fermeture
// println!("{}", owned);
}
Lorsqu'une fermeture doit être transmise à un autre thread ou renvoyée en dehors de sa portée,movec'est particulièrement courant — cela garantit que la fermeture possède les données requises et évite les références pendantes.
Traits de fermeture : Fn / FnMut / FnOnce
Le compilateur Rust implémente automatiquement le trait correspondant pour une closure en fonction de la façon dont elle capture les variables. Comprendre ces trois traits est la clé pour utiliser les closures comme paramètres de fonction ou valeurs de retour.
| Trait | Méthode de capture | Nombre d'appels | Scénario typique |
|---|---|---|---|
Fn | Emprunt immuable (&T) | Plusieurs fois | Accès en lecture seule aux variables capturées |
FnMut | Emprunt mutable (&mut T) | Plusieurs fois | Doit modifier les variables capturées |
FnOnce | Prend possession (T) | Une seule fois | Consomme les variables capturées ; ne peut plus être appelée par la suite |
La relation d'héritage entre les trois est :FnOuiFnMutest un sous-trait de,FnMutOuiFnOnceest un sous-trait de. Autrement dit, une fermeture qui implémenteFnimplémente également automatiquementFnMutetFnOnce。
Remarque :
moveLe mot-clé force simplement la prise de propriété ; cela ne signifie pas que la fermeture doit êtreFnOnce. Si le corps de la fermeture ne consomme pas la valeur capturée, même simoveest ajouté, la fermeture peut encore implémenterFn(peut être appelée plusieurs fois).
Exemple
let name = String::from("example");
// Fermeture Fn : ne fait que lire, ne modifie pas et peut être appelée plusieurs fois
let greet = || println!("Hello, {}!", name);
greet(); // Premier appel
greet(); // Deuxième appel, fonctionne toujours bien
// Closure FnMut : doit modifier les variables capturées
let mut count = 0;
let mut increment = || {
count += 1;
count
};
println!("increment() = {}", increment()); // Sortie : 1
println!("increment() = {}", increment()); // Sortie : 2
// Closure FnOnce : consomme les variables capturées, ne peut être appelée qu'une seule fois
let data = String::from("EXAMPLE");
let consume = move || {
let _ = data; // Déplace data hors de l'environnement de la closure, en le consommant
println!("les données ont été consommées");
};
consume();
// consume(); // Si on le décommente, la compilation échoue : les closures FnOnce ne peuvent être appelées qu'une seule fois
}
Les fermetures comme paramètres et valeurs de retour
Les fermetures peuvent être passées comme paramètres de fonction et renvoyées comme valeurs de retour de fonction. Ce sont les deux utilisations les plus courantes des fermetures dans le développement réel.
Les fermetures comme paramètres
Lorsque vous utilisez une fermeture comme paramètre, vous devez spécifier le type de trait de la fermeture avec une borne générique. Dans l'exemple suivant, le paramètreFest contraint àFn(i32) -> i32, ce qui signifie une fermeture qui prend uni32paramètre et renvoiei32une valeur.
Exemple
fn apply<F>(val: i32, f: F) -> i32
où
F: Fn(i32) -> i32, // F doit implémenter Fn(i32) -> i32
{
f(val)
}
fn main() {
let double = |x| x * 2;
let result = apply(5, double);
println!("Résultat : {}", result); // Sortie : Résultat : 10
// Vous pouvez aussi passer directement une fermeture anonyme
let result2 = apply(3, |x| x + 100);
println!("Résultat2 : {}", result2); // Sortie : Résultat2 : 103
}
Les fermetures comme valeurs de retour
Comme le type d'une fermeture est anonyme, retourner une fermeture nécessiteimpl TraitouBox<dyn Trait>de décrire le type de retour.
Retourner une fermeture avec impl Fn
Lorsque le type de la fermeture retournée peut être déterminé au moment de la compilation, utilisezimpl Fnet aucune allocation sur le tas n'est nécessaire.
Exemple
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
// Doit utiliser move ; sinon x est une référence locale, et x devient invalide après le retour de la fermeture
move |y| x + y
}
fn main() {
let add_five = make_adder(5);
println!("5 + 3 = {}", add_five(3)); // Sortie : 5 + 3 = 8
let add_ten = make_adder(10);
println!("10 + 2 = {}", add_ten(2)); // Sortie : 10 + 2 = 12
}
Utiliser Box<dyn Fn> pour retourner des fermetures
Lorsque vous devez sélectionner dynamiquement différentes fermetures à retourner à l'exécution, utilisezBox<dyn Fn>Allouer la fermeture sur le tas.
Exemple
Box::new(move |y| x + y)
}
fn main() {
let add_ten = make_adder(10);
println!("10 + 2 = {}", add_ten(2)); // Sortie : 10 + 2 = 12
}
| Méthode | Emplacement d'allocation | Scénarios applicables |
|---|---|---|
impl Fn | Pile | Le type de closure peut être déterminé au moment de la compilation, ce qui améliore les performances |
Box<dyn Fn> | Tas | Sélectionner dynamiquement des closures au moment de l'exécution, ou avoir besoin de stocker des closures entre les fonctions |
Cas d'utilisation courants
Les closures sont omniprésentes dans le développement quotidien en Rust. Voici plusieurs des scénarios d'application les plus typiques.
Closures dans les itérateurs
Les closures sont souvent utilisées avec les méthodes d'itérateur pour traiter par lots les éléments d'une collection.
Exemple
let nums = vec![1, 2, 3, 4, 5];
// map : transformer chaque élément
let squared: Vec<i32> = nums.iter().map(|x| x * x).collect();
println!("squares: {:?}", squared); // Sortie : [1, 4, 9, 16, 25]
// filter : filtrer les éléments qui satisfont la condition
let even: Vec<&i32> = nums.iter().filter(|x| *x % 2 == 0).collect();
println!("evens: {:?}", even); // Sortie : [2, 4]
// fold : réduire une collection à une seule valeur
let sum: i32 = nums.iter().fold(0, |acc, x| acc + x);
println!("sum: {}", sum); // Sortie : 15
}
Fermetures et multithreading
En programmation multithread, les fermetures sont souvent utilisées pour définir le corps d'exécution d'un thread.moveLe mot-clé `move` est presque essentiel dans ce scénario, car il déplace la propriété des données dans le nouveau thread, empêchant les références entre threads de devenir invalides.
Exemple
fn main() {
let nums = vec![1, 2, 3, 4, 5];
// Créer un thread pour chaque nombre ; move transfère la propriété de num dans le thread
let handles: Vec<_> = nums.into_iter().map(|num| {
thread::spawn(move || {
num * 2
})
}).collect();
// Attendre que tous les threads se terminent et collecter les résultats
for handle in handles {
let result = handle.join().unwrap();
println!("Résultat : {}", result);
}
}
Fermetures et gestion des erreurs
Les fermetures peuvent retournerResultouOptiontypes qui, combinés aux méthodes d'itérateur, mettent en œuvre une logique concise de gestion des erreurs.
Exemple
let nums = vec![3, -1, 4, -5, 9];
// Utiliser une fermeture pour trouver le premier nombre positif
let first_positive = nums.iter().find(|&&x| x > 0);
match first_positive {
Some(&n) => println!("Premier nombre positif : {}", n), // Sortie : Premier nombre positif : 3
None => println!("Aucun nombre positif"),
}
// Utiliser une closure pour filtrer et transformer, en combinaison avec Result pour gérer les erreurs possibles
let results: Vec<Result<i32, &str>> = nums.iter().map(|&n| {
if n > 0 {
OK(n * 10)
} else {
Err("Les nombres négatifs ne peuvent pas être traités")
}
}).collect();
for r in results {
correspondance r {
Ok(v) => println!("Succès : {}", v),
Err(e) => println!("Erreur : {}", e),
}
}
}
Performance et durées de vie
Performance des closures
Les closures de Rust sont légères. Le compilateur effectue des optimisations d'inlining sur les closures, ce qui rend le surcoût des appels de closure proche de celui d'un appel direct à des fonctions ordinaires. Les closures elles-mêmes n'introduisent pas d'appels de fonctions virtuelles supplémentaires ni d'allocations sur le tas (sauf si l'on utilise explicitementBox)。
Closures et durées de vie
La durée de vie d'une closure est étroitement liée aux variables qu'elle capture. Le système de durées de vie de Rust garantit qu'une closure ne survit à aucune des variables qu'elle capture — si une closure référence une variable locale, le compilateur vous empêchera de renvoyer la closure en dehors de la portée de cette variable au moment de la compilation.
Exemple
let text = String::from("example");
// Correct : utiliser la closure dans la portée de text
let print_text = || println!("{}", text);
print_text(); // Sortie : exemple
// Si vous essayez de renvoyer cette fermeture, le compilateur signalera une erreur :
// fn make_closure() -> impl Fn() {
// let text = String::from("example");
// || println!("{}", text) // Erreur : la durée de vie de text n'est pas assez longue
// }
// Solution : utilisez move pour transférer la propriété dans la fermeture
}
Exemple complet
L'exemple suivant démontre de manière complète les utilisations principales des fermetures telles que la déclaration, la capture de variables externes et le passage en tant qu'arguments.
Exemple
fn apply_operation<F>(num: i32, operation: F) -> i32
où
F: Fn(i32) -> i32,
{
operation(num)
}
fn main() {
let num = 5;
// Définir une fermeture : élever un nombre au carré
let square = |x| x * x;
// Passer la fermeture à la fonction comme argument
let result = apply_operation(num, square);
println!("Le carré de {} est {}", num, result); // Sortie : Le carré de 5 est 25
// Vous pouvez aussi passer directement une fermeture anonyme
let result2 = apply_operation(num, |x| x * x * x);
println!("Le cube de {} est {}", num, result2); // Sortie : Le cube de 5 est 125
}
Exécutez le programme ; la sortie est la suivante :
Square of 5 is 25 Cube of 5 is 125
Résumé
Les fermetures de Rust sont une abstraction puissante qui offre un moyen flexible et expressif d'encapsuler la logique.
Les fermetures peuvent capturer des variables d'environnement et peuvent être passées comme paramètres ou renvoyées comme valeurs de retour. Lorsqu'elles sont combinées avec des itérateurs, les fermetures peuvent facilement mettre en œuvre des tâches complexes de traitement de données.
La conception des fermetures de Rust prend en compte la sûreté, les performances et la durée de vie — le compilateur garantit au moment de la compilation que les fermetures ne référencent pas de variables invalidées, et garantit une abstraction à coût nul pour les appels de fermetures grâce à l'optimisation par inlining.
Autres extensions