Learn Rust Coding · Leçon

Méthodes par défaut

Valeurs par défaut des traits

Méthodes par défaut est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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.

Méthodes avec un corps

Les méthodes d'un trait ne doivent pas se limiter à des signatures. Un trait peut fournir une implémentation par défaut — le corps d'une méthode que les types qui l'implémentent obtiennent automatiquement.

Cela réduit le code répétitif entre de nombreux types.

Une méthode par défaut

Écrivez le corps directement dans le trait. Les types qui implémentent le trait en héritent gratuitement, sans code supplémentaire.

trait Greet {
    fn hello(&self) -> String {
        String::from("Hello there")
    }
}

struct Robot;
impl Greet for Robot {}

fn main() {
    println!("{}", Robot.hello());
}

Remplacer une implémentation par défaut

Tout type qui implémente le trait peut remplacer une implémentation par défaut en fournissant sa propre version. Cette nouvelle version remplace la valeur par défaut pour ce type.

trait Greet {
    fn hello(&self) -> String { String::from("Hello there") }
}

struct Robot;
struct Pirate;
impl Greet for Robot {}
impl Greet for Pirate {
    fn hello(&self) -> String { String::from("Arr!") }
}

fn main() {
    println!("{}", Robot.hello());
    println!("{}", Pirate.hello());
}

Les implémentations par défaut appellent des méthodes requises

Une méthode par défaut peut appeler d'autres méthodes du même trait, y compris celles qui n'ont pas d'implémentation par défaut. C'est un modèle puissant : les types qui implémentent le trait fournissent un petit noyau, et les implémentations par défaut construisent dessus un comportement plus riche.

trait Summary {
    fn title(&self) -> String;
    fn preview(&self) -> String {
        format!("Read more about: {}", self.title())
    }
}

struct Article { headline: String }
impl Summary for Article {
    fn title(&self) -> String { self.headline.clone() }
}

fn main() {
    let a = Article { headline: String::from("Rust Rocks") };
    println!("{}", a.preview());
}

Le modèle de méthode modèle

Cette combinaison de méthodes requises et d'implémentations par défaut constitue le modèle de la méthode modèle. Le trait définit le déroulement général dans les implémentations par défaut et laisse les parties variables sous forme de méthodes requises.

trait Report {
    fn body(&self) -> String;
    fn render(&self) -> String {
        format!("=== REPORT ===\n{}\n==============", self.body())
    }
}

struct Sales;
impl Report for Sales {
    fn body(&self) -> String { String::from("Sales up 10%") }
}

fn main() {
    println!("{}", Sales.render());
}

Plusieurs implémentations par défaut

Un trait peut librement mélanger des méthodes requises et des méthodes par défaut. Les types qui l'implémentent n'ont besoin de fournir que les méthodes requises.

trait Animal {
    fn name(&self) -> String;
    fn legs(&self) -> u32 { 4 }
    fn describe(&self) -> String {
        format!("{} has {} legs", self.name(), self.legs())
    }
}

struct Dog;
impl Animal for Dog {
    fn name(&self) -> String { String::from("Dog") }
}

fn main() {
    println!("{}", Dog.describe());
}

Implémentations par défaut et traits standard

De nombreux traits standard reposent sur des implémentations par défaut. Par exemple, Iterator n'exige que next ; chaque adaptateur et consommateur est une méthode par défaut construite dessus.

C'est pourquoi une seule méthode donne accès à toute la boîte à outils.

Remplacer pour améliorer les performances

Parfois, une implémentation par défaut fonctionne, mais une version spécialisée est plus rapide. Les types qui implémentent le trait peuvent ne remplacer que cette méthode tout en conservant le reste des implémentations par défaut.

trait Counter {
    fn items(&self) -> Vec<i32>;
    fn total(&self) -> i32 {
        self.items().iter().sum()
    }
}

struct Fast { precomputed: i32 }
impl Counter for Fast {
    fn items(&self) -> Vec<i32> { vec![] }
    fn total(&self) -> i32 { self.precomputed }
}

fn main() {
    println!("{}", Fast { precomputed: 99 }.total());
}

Garder des traits ergonomiques

Une bonne conception de trait consiste à rendre obligatoire un petit ensemble de méthodes et à fournir des implémentations par défaut pratiques pour le reste. Les types qui l'implémentent fournissent un minimum de travail tout en obtenant une interface riche.

Une réserve

Une méthode par défaut ne peut utiliser que les autres méthodes du trait et le type situé derrière self en passant par ces méthodes ; elle ne peut pas accéder directement aux champs d'un type dont elle ignore l'implémentation. Concevez les implémentations par défaut autour des propres méthodes du trait.

Implémentations par défaut ou requises : aperçu

Une méthode de trait avec un corps est une méthode par défaut ; une méthode qui ne possède qu'une signature est une méthode requise. Les types qui implémentent le trait doivent fournir chaque méthode requise, mais peuvent laisser les implémentations par défaut inchangées.

trait Logger {
    fn line(&self) -> String;
    fn log(&self) {
        println!("LOG: {}", self.line());
    }
}

struct App;
impl Logger for App {
    fn line(&self) -> String { String::from("started") }
}

fn main() {
    App.log();
}

Vérification rapide

Testez votre compréhension des méthodes par défaut.

Récapitulatif

Vous avez appris le fonctionnement des implémentations par défaut des traits :

Une méthode de trait peut inclure un corps sous forme d'implémentation par défaut
Les types qui l'implémentent en héritent gratuitement et peuvent la remplacer
Les implémentations par défaut peuvent appeler des méthodes requises, ce qui permet le modèle de méthode modèle
Cela rend les traits ergonomiques grâce à un ensemble réduit de méthodes obligatoires

Questions Fréquemment Posées

La leçon « Méthodes par défaut » est-elle gratuite ?

Oui — le texte complet de « Méthodes par défaut » 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 « Méthodes par défaut » ?

Valeurs par défaut des traits 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 4 sur 4.

Combien de temps prend la leçon « Méthodes par défaut » ?

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.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding