Lær at programmere i Rust · Lektion

Definition af traits

Delt adfærd

Lektion 1 af 413 trin

Definition af traits er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 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 er et trait?

Et trait definerer fælles adfærd — et sæt metoder, som en type kan implementere. Det minder om en grænseflade i andre sprog.

Traits lader forskellige typer følge den samme fælles kontrakt.

Erklæring af et trait

Brug nøgleordet trait efterfulgt af metodesignaturer. Signaturerne erklærer, hvad implementeringer skal levere.

trait Greet {
    fn hello(&self) -> String;
}

fn main() {
    println!("trait declared");
}

Implementering af et trait

Brug impl TraitName for Type til at levere metoderne. Signaturen skal stemme nøjagtigt overens med traitet.

trait Greet {
    fn hello(&self) -> String;
}

struct Dog;

impl Greet for Dog {
    fn hello(&self) -> String {
        String::from("Woof")
    }
}

fn main() {
    let d = Dog;
    println!("{}", d.hello());
}

Mange typer, ét trait

Flere typer kan implementere det samme trait, hver på sin egen måde. Sådan samler traits adfærd på tværs af ellers ubeslægtede typer.

trait Greet { fn hello(&self) -> String; }

struct Dog;
struct Cat;

impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

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

Traits som funktionsparametre

Syntaksen impl Trait accepterer enhver type, der implementerer traitet. Funktionen virker ensartet uden at kende den konkrete type.

trait Greet { fn hello(&self) -> String; }
struct Dog;
impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }

fn announce(g: &impl Greet) {
    println!("It says: {}", g.hello());
}

fn main() {
    announce(&Dog);
}

Trait-begrænsninger på generiske typer

Du kan kræve, at en generisk type implementerer et trait, ved hjælp af en trait-begrænsning. Det giver adgang til traitets metoder inde i funktionen.

trait Greet { fn hello(&self) -> String; }
struct Cat;
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

fn shout<T: Greet>(g: &T) {
    println!("{}!", g.hello().to_uppercase());
}

fn main() {
    shout(&Cat);
}

Flere begrænsninger med +

Kræv flere traits på én gang med +. Her skal en værdi implementere både et brugerdefineret trait og standardtraitet Clone.

trait Named { fn name(&self) -> String; }

#[derive(Clone)]
struct Item { label: String }

impl Named for Item {
    fn name(&self) -> String { self.label.clone() }
}

fn describe<T: Named + Clone>(t: &T) {
    let copy = t.clone();
    println!("named {}", copy.name());
}

fn main() {
    describe(&Item { label: String::from("box") });
}

where-klausulen

Ved mange begrænsninger gør en where-klausul signaturen mere overskuelig ved at flytte begrænsningerne ned under den.

use std::fmt::Debug;

fn print_all<T>(items: &[T])
where
    T: Debug,
{
    for it in items {
        println!("{:?}", it);
    }
}

fn main() {
    print_all(&[1, 2, 3]);
}

Traits kan have flere metoder

Et trait kan erklære mange metoder. Implementeringer skal levere alle påkrævede metoder, så typen får et komplet sæt af adfærd.

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> String;
}

struct Square { side: f64 }

impl Shape for Square {
    fn area(&self) -> f64 { self.side * self.side }
    fn name(&self) -> String { String::from("square") }
}

fn main() {
    let s = Square { side: 3.0 };
    println!("{} area {}", s.name(), s.area());
}

Hvorfor traits er vigtige

Traits muliggør polymorfi uden nedarvning. De driver generiske typer, operatoroverbelastning (Add), formatering (Display) og store dele af standardbiblioteket.

De er kernen i Rusts abstraktionsmodel.

Sammenhængsreglen

Forældreløshedsreglen siger, at du kun kan implementere et trait for en type, hvis du ejer traitet eller typen. Det forhindrer modstridende implementeringer på tværs af crates.

Hurtigt tjek

Test din forståelse af traits.

Besvar den i den interaktive lektion

Opsummering

Du har lært at definere og bruge traits:

trait erklærer fælles adfærd
impl Trait for Type leverer metoderne
Trait-begrænsninger (T: Trait, +, where) begrænser generiske typer
Forældreløshedsreglen holder implementeringer sammenhængende

Gratis at komme i gang

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Definition af traits” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Definition af traits”, 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 “Definition af traits”?

Delt adfærd 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 1 af 4.

Hvor lang tid tager lektionen “Definition af traits”?

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.

Alle lektioner i dette kursus

← Tilbage til Lær at programmere i Rust