Metody domyślne
Wartości domyślne cech
Metody domyślne to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Metody z treścią
Metody traitów nie muszą być tylko sygnaturami. Trait może udostępniać implementację domyślną — treść metody, którą implementujący go typ otrzymuje automatycznie.
Ogranicza to powtarzalny kod w wielu typach.
Metoda domyślna
Treść metody należy zapisać bezpośrednio wewnątrz traitu. Typy implementujące ten trait dziedziczą ją bez dodatkowego kodu.
trait Greet {
fn hello(&self) -> String {
String::from("Hello there")
}
}
struct Robot;
impl Greet for Robot {}
fn main() {
println!("{}", Robot.hello());
}Przesłanianie implementacji domyślnej
Każdy typ implementujący trait może przesłonić implementację domyślną, udostępniając własną wersję. Własna implementacja zastępuje domyślną dla tego typu.
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());
}Domyślne implementacje wywołujące wymagane metody
Metoda domyślna może wywoływać inne metody tego samego traitu, nawet te bez implementacji domyślnej. To potężny wzorzec: implementujący dostarczają niewielki rdzeń, a implementacje domyślne budują na nim bogatsze zachowanie.
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());
}Wzorzec metody szablonowej
Połączenie metod wymaganych i domyślnych to wzorzec metody szablonowej. Trait definiuje ogólny przebieg w implementacjach domyślnych, a zmienne elementy pozostawia jako metody wymagane.
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());
}Wiele implementacji domyślnych
Trait może dowolnie łączyć metody wymagane i domyślne. Implementujący muszą dostarczyć tylko te wymagane.
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());
}Implementacje domyślne a standardowe traity
Wiele standardowych traitów korzysta z implementacji domyślnych. Na przykład Iterator wymaga tylko next; każdy adapter i konsument jest metodą domyślną zbudowaną na tej podstawie.
Dlatego jedna metoda daje dostęp do całego zestawu narzędzi.
Przesłanianie ze względu na wydajność
Czasami implementacja domyślna działa poprawnie, ale wyspecjalizowana wersja jest szybsza. Implementujący mogą przesłonić tylko tę metodę, zachowując pozostałe implementacje domyślne.
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());
}Ergonomiczne projektowanie traitów
Dobrze zaprojektowany trait wymaga niewielkiego zestawu metod i udostępnia wygodne implementacje domyślne dla pozostałych. Implementujący wykonują minimalną pracę, ale otrzymują bogaty interfejs.
Zastrzeżenie
Metoda domyślna może używać tylko innych metod traitu oraz typu ukrytego za self za ich pośrednictwem; nie może bezpośrednio uzyskiwać dostępu do pól nieznanego typu implementującego trait. Projektuj implementacje domyślne wokół metod samego traitu.
Domyślne i wymagane — szybkie porównanie
Metoda traitu z treścią jest domyślna, a metoda zawierająca tylko sygnaturę jest wymagana. Implementujący muszą dostarczyć każdą metodę wymaganą, ale mogą pozostawić domyślne bez zmian.
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();
}Szybki sprawdzian
Sprawdź, jak dobrze rozumiesz metody domyślne.
Podsumowanie
Omówiono domyślne implementacje traitów:
- Metoda traitu może zawierać treść jako implementację domyślną
- Implementujący dziedziczą ją bez dodatkowego kodu i mogą ją przesłonić
- Implementacje domyślne mogą wywoływać metody wymagane, umożliwiając zastosowanie wzorca metody szablonowej
- Pozwala to zachować ergonomię traitów przy niewielkim zestawie metod wymaganych
Często zadawane pytania
Czy lekcja „Metody domyślne” jest bezpłatna?
Tak — pełny tekst „Metody domyślne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Co nauczysz się w „Metody domyślne”?
Wartości domyślne cech Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?
Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Metody domyślne”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?
Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.