Fermetures
Fonctions anonymes
Fermetures est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce qu'une fermeture ?
Une fermeture est une fonction anonyme que vous pouvez stocker dans une variable et appeler ultérieurement. Elle s'écrit avec des barres verticales autour des paramètres.
fn main() {
let add_one = |x| x + 1;
println!("{}", add_one(4));
}Syntaxe des fermetures
Les paramètres se placent entre |...|, suivis du corps. Avec une seule expression, les accolades ne sont pas nécessaires.
|x| x + 1— un paramètre.|a, b| a + b— deux paramètres.
fn main() {
let multiply = |a, b| a * b;
println!("{}", multiply(3, 5));
}Fermetures sur plusieurs lignes
Pour plusieurs instructions, placez le corps entre accolades, comme pour une fonction.
fn main() {
let describe = |n: i32| {
let doubled = n * 2;
println!("{} doubled is {}", n, doubled);
};
describe(7);
}Capturer l'environnement
Contrairement à une fonction ordinaire, une fermeture peut capturer des variables de la portée environnante et les utiliser à l'intérieur.
fn main() {
let factor = 10;
let scale = |x| x * factor;
println!("{}", scale(5));
}Inférence de type dans les fermetures
Les fermetures déduisent généralement les types de leurs paramètres et de leur valeur de retour en fonction de leur utilisation, les annotations étant donc facultatives.
Vous pouvez ajouter des types pour plus de clarté lorsque c'est nécessaire.
fn main() {
let greet = |name: &str| -> String {
format!("Hello, {}!", name)
};
println!("{}", greet("Rust"));
}Fermetures comme arguments
De nombreuses méthodes standard acceptent une fermeture. Par exemple, map applique une fermeture à chaque élément.
fn main() {
let nums = vec![1, 2, 3];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}Filtrer avec des fermetures
La méthode filter conserve uniquement les éléments pour lesquels la fermeture renvoie true.
fn main() {
let nums = vec![1, 2, 3, 4, 5, 6];
let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
println!("{:?}", evens);
}Stocker des fermetures
Les fermetures ont des types anonymes uniques, mais vous pouvez les stocker dans une variable et les réutiliser.
fn main() {
let is_even = |n: i32| n % 2 == 0;
println!("{} {}", is_even(4), is_even(7));
}Fermetures et fonctions
Différences :
- Les fonctions ne peuvent pas capturer les variables environnantes ; les fermetures le peuvent.
- Les fermetures sont anonymes et souvent courtes.
- Les types des fermetures sont généralement déduits.
fn main() {
let base = 100;
let bonus = |earned: i32| earned + base;
println!("{}", bonus(25));
}Renvoyer des valeurs calculées
Combinez les fermetures avec les itérateurs pour calculer des résultats dans une chaîne de traitement claire et expressive.
fn main() {
let nums = vec![10, 20, 30];
let total: i32 = nums.iter().map(|x| x + 1).sum();
println!("total {}", total);
}Les fermetures capturent par référence
Par défaut, une fermeture emprunte les variables capturées. Vous pouvez tout de même les lire à l'extérieur ensuite (lorsqu'elles ont seulement été empruntées).
fn main() {
let name = String::from("Ada");
let printer = || println!("Name: {}", name);
printer();
println!("still usable: {}", name);
}Vérification rapide
Rappelez-vous une capacité essentielle des fermetures.
Récapitulatif
Les fermetures dans Rust :
- Fonctions anonymes écrites sous la forme
|params| body. - Peuvent capturer des variables de leur environnement.
- Ont des types généralement déduits.
- Sont largement utilisées avec les méthodes d'itérateur comme
mapetfilter.
fn main() {
let tax = 0.2;
let with_tax = |price: f64| price * (1.0 + tax);
println!("{}", with_tax(50.0));
}Questions Fréquemment Posées
La leçon « Fermetures » est-elle gratuite ?
Oui — le texte complet de « Fermetures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Fermetures » ?
Fonctions anonymes Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Fermetures » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.