Standardmethoden
Trait-Standards
Standardmethoden ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Methoden mit Implementierung
Trait-Methoden müssen nicht nur aus Signaturen bestehen. Ein Trait kann eine Standardimplementierung bereitstellen – einen Methodenrumpf, den Implementierungen automatisch erhalten.
Das verringert redundanten Code über viele Typen hinweg.
Eine Standardmethode
Schreiben Sie den Rumpf direkt in das Trait. Typen, die das Trait implementieren, erben ihn kostenlos und benötigen keinen zusätzlichen Code.
trait Greet {
fn hello(&self) -> String {
String::from("Hello there")
}
}
struct Robot;
impl Greet for Robot {}
fn main() {
println!("{}", Robot.hello());
}Eine Standardimplementierung überschreiben
Jede Implementierung kann eine Standardimplementierung überschreiben, indem sie eine eigene Version bereitstellt. Für diesen Typ ersetzt die Überschreibung die Standardimplementierung.
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());
}Standards rufen erforderliche Methoden auf
Eine Standardmethode kann andere Methoden desselben Traits aufrufen, auch solche ohne Standardimplementierung. Das ist ein leistungsfähiges Muster: Implementierungen liefern einen kleinen Kern, auf dem die Standards umfangreicheres Verhalten aufbauen.
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());
}Das Template-Method-Muster
Diese Kombination aus erforderlichen Methoden und Standardimplementierungen ist das Template-Method-Muster. Das Trait definiert den allgemeinen Ablauf in den Standardimplementierungen und überlässt die variablen Teile den erforderlichen Methoden.
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());
}Mehrere Standardimplementierungen
Ein Trait kann erforderliche Methoden und Standardimplementierungen beliebig kombinieren. Implementierungen müssen nur die erforderlichen Methoden bereitstellen.
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());
}Standards und Standard-Traits
Viele Standard-Traits nutzen Standardimplementierungen. Iterator erfordert beispielsweise nur next; jeder Adapter und jeder Consumer ist eine darauf aufbauende Standardmethode.
Deshalb erschließt eine einzige Methode die gesamte Werkzeugpalette.
Überschreiben für bessere Leistung
Manchmal funktioniert eine Standardimplementierung, aber eine spezialisierte Version ist schneller. Implementierungen können nur diese Methode überschreiben und die übrigen Standardimplementierungen beibehalten.
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());
}Ergonomische Traits gestalten
Gutes Trait-Design bedeutet: Machen Sie nur wenige Methoden erforderlich und stellen Sie für den Rest praktische Standardimplementierungen bereit. Implementierungen benötigen nur minimale Arbeit und erhalten trotzdem eine umfangreiche Schnittstelle.
Ein Vorbehalt
Eine Standardmethode kann nur andere Trait-Methoden und über diese den Typ hinter self verwenden; auf Felder einer unbekannten Implementierung kann sie nicht direkt zugreifen. Richten Sie Standardimplementierungen an den eigenen Methoden des Traits aus.
Standards und erforderliche Methoden im Überblick
Eine Trait-Methode mit Rumpf ist eine Standardimplementierung; eine Methode mit nur einer Signatur ist erforderlich. Implementierungen müssen jede erforderliche Methode bereitstellen, dürfen Standardimplementierungen aber unverändert lassen.
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();
}Kurzer Test
Testen Sie Ihr Verständnis von Standardmethoden.
Zusammenfassung
Sie haben Standardimplementierungen in Traits kennengelernt:
- Eine Trait-Methode kann als Standardimplementierung einen Rumpf enthalten
- Implementierungen erben ihn kostenlos und können ihn überschreiben
- Standardimplementierungen können erforderliche Methoden aufrufen und ermöglichen so das Template-Method-Muster
- Das hält Traits mit wenigen erforderlichen Methoden ergonomisch
Häufig gestellte Fragen
Ist die Lektion „Standardmethoden“ kostenlos?
Ja — der vollständige Text von „Standardmethoden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Standardmethoden“?
Trait-Standards Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Standardmethoden“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.