Skrivning af generisk kode i Rust
Lær at skrive funktioner og datastrukturer, der fungerer med flere typer, så koden kan genbruges uden at give afkald på typesikkerhed.
Skrivning af generisk kode i Rust er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 3. 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 3 lektioner i alt.
Hvorfor skrive generisk kode?
Forestil dig, at du skal bruge en funktion, der finder det største element på en liste. Hvad hvis du skal bruge den til tal, derefter tegn og så brugerdefinerede objekter?
Uden generiske typer skulle du skrive en separat funktion for hver type, hvilket ville føre til en masse duplikeret kode. Det er her, generiske typer kommer ind i billedet!
Introduktion til generiske typer
Generiske typer giver dig mulighed for at skrive kode, der fungerer med flere typer, uden at gentage dig selv. Det er en måde at skrive fleksible og genanvendelige funktioner eller datastrukturer på.
Tænk på det som en skabelon, der kan tilpasses forskellige materialer.
Din første generiske funktion
For at gøre en funktion generisk erklærer vi typeparametre i vinkelparenteser <> efter funktionsnavnet. Et almindeligt navn på en typeparameter er T (for Type).
Denne funktion, print_anything, kan nu udskrive alle typer!
fn print_anything<T>(item: T) {
println!("The item is: {}", item);
}
pub fn main() {
print_anything(5);
print_anything("hello");
print_anything(true);
}Typeparametre forklaret
<T> i fn print_anything<T>(item: T) betyder, at T er en pladsholder for en type. Når du kalder funktionen med en i32, bliver T til i32.
- Typeparametre: Generiske typer navngives normalt med store bogstaver, f.eks.
T,UogV. - Fleksibilitet: Compileren finder den konkrete type på kompileringstidspunktet.
Tilføj funktionalitet: trait-begrænsninger
Nogle gange skal din generiske funktion kræve, at typeparameteren T har bestemte egenskaber. Hvis du f.eks. vil sammenligne to T-værdier, skal T kunne sammenlignes.
Vi tilføjer trait-begrænsninger for at angive disse krav. Her betyder T: PartialOrd + Copy, at T skal implementere traitene PartialOrd (delvis ordning til sammenligning) og Copy.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
pub fn main() {
let number_list = vec![34, 50, 25, 100, 65];
println!("Largest number: {}", largest(&number_list));
let char_list = vec!['y', 'm', 'a', 'q'];
println!("Largest char: {}", largest(&char_list));
}Syntaks for flere trait-begrænsninger
Du kan kræve flere traits for en generisk type ved at bruge syntaksen +, f.eks. T: TraitA + TraitB.
Ved komplekse begrænsninger kan du også bruge en where-klausul efter funktionssignaturen, hvilket kan gøre signaturen mere overskuelig:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Generiske structs
Ligesom funktioner kan du definere structs, der er generiske over en eller flere typeparametre. Det giver dine datastrukturer mulighed for at indeholde data af enhver angivet type.
Structen Point<T> kan indeholde koordinater af enhver type T (f.eks. i32 og f64).
struct Point<T> {
x: T,
y: T,
}
pub fn main() {
let integer_point = Point {
x: 5,
y: 10
};
let float_point = Point {
x: 1.0,
y: 4.0
};
println!("Int Point: ({}, {})",
integer_point.x, integer_point.y);
println!("Float Point: ({}, {})",
float_point.x, float_point.y);
}Implementering af metoder på generiske structs
Når du implementerer metoder for en generisk struct, skal du angive de generiske typeparametre efter impl.
Du kan også tilføje trait-begrænsninger til metoder, hvis en metode specifikt kræver en bestemt funktionalitet fra sine generiske typer.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
pub fn main() {
let p = Point {
x: 5,
y: 10
};
println!("p.x = {}", p.x());
}Generiske typer og ydeevne
En af Rusts styrker er, at generiske typer er en abstraktion uden omkostninger. Det betyder, at brug af generiske typer ikke medfører en ydeevnestraf under kørsel.
Rust opnår dette gennem monomorfisering: På kompileringstidspunktet genererer compileren specialiserede versioner af din generiske kode for hver konkret type, den bruges med. Derfor bliver largest<i32> og largest<char> til to forskellige, optimerede funktioner.
Test din viden
Hvilke af følgende udsagn om Rusts generiske typer er SANDE?
Opsummering: De generiske typers styrke
I denne lektion har du lært det grundlæggende i at skrive generisk kode i Rust:
- Hvad de er: En måde at skrive fleksibel og genanvendelig kode på.
- Generiske funktioner: Brug af
<T>til typeparametre. - Trait-begrænsninger: Angivelse af påkrævet funktionalitet med
T: Trait. - Generiske structs: Oprettelse af datastrukturer, der indeholder generiske typer.
- Uden omkostninger: Rust kompilerer generiske typer til specifik kode, så der ikke er nogen ydeevnestraf under kørsel.
Generiske typer er en hjørnesten i idiomatisk Rust og muliggør effektive, typesikre abstraktioner!
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 “Skrivning af generisk kode i Rust” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Skrivning af generisk kode i Rust”, 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 3 lektioner i alt.
Hvad lærer jeg i “Skrivning af generisk kode i Rust”?
Lær at skrive funktioner og datastrukturer, der fungerer med flere typer, så koden kan genbruges uden at give afkald på typesikkerhed. 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 3.
Hvor lang tid tager lektionen “Skrivning af generisk kode i Rust”?
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
- Skrivning af generisk kode i Rust
- Definition og implementering af traits
- Avanceret brug af traits: associated types