Learn Rust Coding · Lezione

Metodi predefiniti

Valori predefiniti dei trait

Metodi predefiniti è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Metodi con un corpo

I metodi di un trait non devono contenere solo firme. Un trait può fornire un'implementazione predefinita: un corpo del metodo che gli implementatori ricevono automaticamente.

Questo riduce il codice ripetitivo tra molti tipi.

Un metodo predefinito

Scriva il corpo direttamente all'interno del trait. I tipi che implementano il trait lo ereditano gratuitamente, senza codice aggiuntivo.

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

struct Robot;
impl Greet for Robot {}

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

Sovrascrivere un'implementazione predefinita

Qualsiasi implementatore può sovrascrivere un'implementazione predefinita fornendo una propria versione. La sovrascrittura sostituisce l'implementazione predefinita per quel tipo.

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());
}

Implementazioni predefinite che chiamano metodi obbligatori

Un metodo predefinito può chiamare altri metodi dello stesso trait, anche quelli privi di implementazione predefinita. È uno schema potente: gli implementatori forniscono un nucleo ridotto e le implementazioni predefinite costruiscono comportamenti più ricchi.

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());
}

Il pattern Template Method

Questa combinazione di elementi obbligatori e predefiniti è il pattern template method. Il trait definisce il flusso generale nelle implementazioni predefinite e lascia le parti variabili come metodi obbligatori.

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());
}

Più implementazioni predefinite

Un trait può combinare liberamente metodi obbligatori e predefiniti. Gli implementatori devono fornire solo quelli obbligatori.

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());
}

Implementazioni predefinite e trait standard

Molti trait standard si basano sulle implementazioni predefinite. Ad esempio, Iterator richiede solo next; ogni adattatore e consumatore è un metodo predefinito costruito su di esso.

Per questo un solo metodo rende disponibile l'intera cassetta degli strumenti.

Sovrascrivere per le prestazioni

A volte l'implementazione predefinita funziona, ma una versione specializzata è più veloce. Gli implementatori possono sovrascrivere solo quel metodo, mantenendo tutte le altre implementazioni predefinite.

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());
}

Mantenere i trait ergonomici

Un buon design dei trait richiede un insieme ridotto di metodi e fornisce implementazioni predefinite comode per tutti gli altri. Gli implementatori svolgono il lavoro minimo, ma ottengono un'interfaccia ricca.

Un'avvertenza

Un metodo predefinito può usare solo altri metodi del trait e il tipo dietro self tramite questi metodi; non può accedere direttamente ai campi di un implementatore sconosciuto. Progetti le implementazioni predefinite intorno ai metodi del trait stesso.

Predefiniti e obbligatori a colpo d'occhio

Un metodo di un trait con un corpo è predefinito; uno con la sola firma è obbligatorio. Gli implementatori devono fornire ogni metodo obbligatorio, ma possono lasciare invariati quelli predefiniti.

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();
}

Verifica rapida

Metta alla prova la sua comprensione dei metodi predefiniti.

Riepilogo

Ha imparato a conoscere le implementazioni predefinite dei trait:

Un metodo di un trait può includere un corpo come implementazione predefinita
Gli implementatori lo ereditano gratuitamente e possono sovrascriverlo
Le implementazioni predefinite possono chiamare metodi obbligatori, rendendo possibile il pattern template method
Questo mantiene i trait ergonomici, con un insieme ridotto di metodi obbligatori

Domande Frequenti

La lezione «Metodi predefiniti» è gratuita?

Sì — il testo completo di «Metodi predefiniti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Metodi predefiniti»?

Valori predefiniti dei trait Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Metodi predefiniti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding