Standardmetoder
Standarder for traits
Standardmetoder er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Metoder med en krop
Trait-metoder behøver ikke kun at være signaturer. Et trait kan levere en standardimplementering — en metodekrop, som implementeringer automatisk får.
Det reducerer gentagen standardkode på tværs af mange typer.
En standardmetode
Skriv kroppen direkte inde i traitet. Typer, der implementerer traitet, arver den gratis uden ekstra kode.
trait Greet {
fn hello(&self) -> String {
String::from("Hello there")
}
}
struct Robot;
impl Greet for Robot {}
fn main() {
println!("{}", Robot.hello());
}At tilsidesætte en standard
Enhver implementering kan tilsidesætte en standard ved at levere sin egen version. Tilsidesættelsen erstatter standarden for den pågældende 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());
}Standarder, der kalder påkrævede metoder
En standardmetode kan kalde andre metoder i det samme trait, også metoder uden en standard. Det er et stærkt mønster: Implementeringerne leverer en lille kerne, og standarderne bygger en mere omfattende adfærd oven på den.
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());
}Skabelonmetodemønstret
Denne kombination af påkrævede metoder og standarder er skabelonmetodemønstret. Traitet definerer det overordnede forløb i standarderne og overlader de variable dele til de påkrævede metoder.
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());
}Flere standarder
Et trait kan frit blande påkrævede metoder og standardmetoder. Implementeringerne behøver kun at levere de påkrævede.
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());
}Standarder og standardtraits
Mange standardtraits er afhængige af standarder. For eksempel kræver Iterator kun next; alle adaptere og forbrugere er standardmetoder, der bygger på den.
Det er derfor, at én metode åbner for hele værktøjskassen.
Tilsidesættelse for bedre ydeevne
Nogle gange virker en standard, men en specialiseret version er hurtigere. Implementeringer kan tilsidesætte netop denne metode og samtidig beholde resten af standarderne.
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());
}At gøre traits nemme at bruge
Godt trait-design: Gør et lille sæt metoder påkrævede, og lever praktiske standarder til resten. Implementeringerne udfører et minimum af arbejde, men får en omfattende grænseflade.
En begrænsning
En standardmetode kan kun bruge andre trait-metoder og typen bag self gennem dem; den kan ikke få direkte adgang til felter i en ukendt implementering. Design standarderne omkring traitets egne metoder.
Standarder og påkrævede metoder på et øjeblik
En trait-metode med en krop er en standard; en metode med kun en signatur er påkrævet. Implementeringerne skal levere alle påkrævede metoder, men kan lade standarderne være urørte.
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();
}Hurtigt tjek
Test din forståelse af standardmetoder.
Opsummering
Du har lært om trait-standarder:
- En trait-metode kan indeholde en krop som standardimplementering
- Implementeringer arver den gratis og kan tilsidesætte den
- Standarder kan kalde påkrævede metoder, hvilket muliggør skabelonmetodemønstret
- Det gør traits nemme at bruge med få påkrævede metoder
Lær Rust med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 144
Ofte stillede spørgsmål
Er lektionen “Standardmetoder” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Standardmetoder”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Standardmetoder”?
Standarder for traits Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær at programmere i Rust?
Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.
Hvor lang tid tager lektionen “Standardmetoder”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?
Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.