Trait-grænser
Begræns generics med traits.
Trait-grænser er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 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.
Hvad trait-begrænsninger gør
En trait-begrænsning begrænser en generisk type til typer, der implementerer en bestemt trait. Den fortæller compileren, hvilken adfærd typen garanterer.
Det giver adgang til traitens metoder i den generiske kode, samtidig med at funktionen kan bruges til mange typer.
Inline-syntaks for begrænsninger
Den enkleste form placerer begrænsningen lige efter typeparameteren: T: Trait. Her skal T implementere Display, så den kan udskrives.
Inde i funktionen kan du nu kalde alle metoder, som Display stiller til rådighed.
use std::fmt::Display;
fn show<T: Display>(value: T) {
println!("value = {}", value);
}En brugerdefineret trait
Begrænsninger fungerer også med dine egne traits. Definér en trait med en metode, og begræns derefter en generisk funktion med den.
Denne Summary-trait kræver en summarize-metode, der returnerer en streng.
trait Summary {
fn summarize(&self) -> String;
}Implementér og begræns
Implementér traiten for en type, hvorefter en begrænset funktion kan acceptere alle typer, der implementerer den. Funktionen kalder trait-metoden uden at kende den konkrete type.
Dette komplette program udskriver en opsummering af en Article.
trait Summary { fn summarize(&self) -> String; }
struct Article { title: String }
impl Summary for Article {
fn summarize(&self) -> String {
format!("Article: {}", self.title)
}
}
fn notify<T: Summary>(item: &T) {
println!("{}", item.summarize());
}
fn main() {
let a = Article { title: String::from("Rust") };
notify(&a);
}Kombinér begrænsninger med +
Kræv flere traits på én gang ved at forbinde dem med +. Her skal T implementere både Display og Clone.
Funktionen kan derefter udskrive værdien og også klone den.
use std::fmt::Display;
fn process<T: Display + Clone>(value: T) {
let copy = value.clone();
println!("{}", copy);
}impl Trait i argumenter
Syntaksen impl Trait på argumentplads er en kortere form for en simpel begrænsning. item: &impl Summary betyder det samme som en parameter med <T: Summary>.
Det er kortfattet i tilfælde med ét argument, men giver mindre kontrol, når typen genbruges.
trait Summary { fn summarize(&self) -> String; }
fn notify(item: &impl Summary) {
println!("{}", item.summarize());
}Returnering af impl Trait
Du kan også returnere impl Trait for at skjule en konkret type, samtidig med at du lover, at den implementerer en trait. Det er praktisk til closures og iteratorer.
Den kaldende kode ved kun, at resultatet implementerer den navngivne trait.
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
move |x| x + n
}
fn main() {
let add5 = make_adder(5);
println!("{}", add5(10));
}Begrænsninger aktiverer operatorer
Operatorer svarer til traits: + kræver Add, == kræver PartialEq, og sammenligninger kræver PartialOrd. Ved at begrænse typer med disse traits kan generisk kode bruge operatorerne.
Her kræver summering, at T implementerer Add med sig selv.
use std::ops::Add;
fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
a + b
}Standardmetoder i traits
Traits kan indeholde standardimplementationer af metoder. Implementeringer kan tilsidesætte dem eller benytte standarden. Generiske typer med begrænsninger bruger den implementation, der er gældende.
Denne Summary har en standard-summarize, som typer kan beholde uændret.
trait Summary {
fn summarize(&self) -> String {
String::from("(no summary)")
}
}
struct Note;
impl Summary for Note {}Statisk og dynamisk dispatch
Trait-begrænsninger bruger statisk dispatch: compileren vælger den præcise metode på kompileringstidspunktet via monomorfisering. Derimod bruger dyn Trait dynamisk dispatch gennem en vtable.
Begrænsninger er som regel hurtigere; dyn bytter hastighed for mindre binære filer og fleksibilitet under kørsel.
Begrænsninger på generiske structs
Trait-begrænsninger er ikke begrænset til funktioner. Du kan kræve dem, når du definerer en struct, så alle instanser opfylder trait’en.
Her garanterer enhver Sortable<T>, at dens elementer kan sammenlignes.
struct Sortable<T: PartialOrd> {
items: Vec<T>,
}Hurtigt tjek
Test din forståelse af trait-begrænsninger.
Opsamling
Trait-begrænsninger begrænser generiske typer, så compileren tillader trait’ens metoder og operatorer. Kombinér traits med +, og brug impl Trait som kortere form i argumenter eller returværdier.
Begrænsninger giver statisk dispatch uden ekstra overhead, i modsætning til dynamisk dispatch med dyn Trait.
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 “Trait-grænser” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Trait-grænser”, 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 “Trait-grænser”?
Begræns generics med 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 3 af 4.
Hvor lang tid tager lektionen “Trait-grænser”?
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.