Skrive generisk kode i Rust
Lær å skrive funksjoner og datastrukturer som fungerer med flere typer, slik at koden blir mer gjenbrukbar uten at typesikkerheten svekkes.
Skrive generisk kode i Rust er en gratis leksjon i Lær Rust-programmering på CoddyKit. Dette er leksjon 1 av 3. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær Rust-programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær Rust-programmering inneholder totalt 3 leksjoner.
Hvorfor skrive generisk kode?
Se for deg at du trenger en funksjon som finner det største elementet i en liste. Hva om du trenger den for tall, deretter for tegn og så for egendefinerte objekter?
Uten generiske typer måtte du skrevet en separat funksjon for hver type, noe som ville ført til mye duplisert kode. Det er her generiske typer kommer inn!
Introduksjon til generiske typer
Generiske typer lar deg skrive kode som fungerer med flere typer uten at du må gjenta deg selv. De er en måte å skrive fleksible og gjenbrukbare funksjoner eller datastrukturer på.
Tenk på det som en tegning som kan tilpasses ulike materialer.
Din første generiske funksjon
For å gjøre en funksjon generisk deklarerer vi typeparametere i vinkelparenteser <> etter funksjonsnavnet. Et vanlig navn på en typeparameter er T (for Type).
Funksjonen print_anything kan nå skrive ut 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);
}Forklaring av typeparametere
<T> i fn print_anything<T>(item: T) betyr at T er en plassholder for en type. Når du kaller funksjonen med en i32, blir T til i32.
- Typeparametere: Generiske typer navngis vanligvis med store bokstaver, for eksempel
T,UogV. - Fleksibilitet: Kompilatoren finner den konkrete typen ved kompilering.
Legge til oppførsel: trait-begrensninger
Noen ganger trenger den generiske funksjonen din at typeparameteren T har bestemte egenskaper. Hvis du for eksempel vil sammenligne to T-verdier, må T kunne sammenlignes.
Vi legger til trait-begrensninger for å angi disse kravene. Her betyr T: PartialOrd + Copy at T må implementere traitene PartialOrd (delvis ordning for 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-begrensninger
Du kan kreve flere traits for en generisk type ved å bruke syntaksen +, for eksempel T: TraitA + TraitB.
For komplekse begrensninger kan du også bruke en where-setning etter funksjonssignaturen. Det kan gjøre signaturen ryddigere:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Generiske strukturer
Akkurat som funksjoner kan du definere strukturer som er generiske over én eller flere typeparametere. Dette lar datastrukturene inneholde data av en hvilken som helst angitt type.
Strukturen Point<T> kan inneholde koordinater av en hvilken som helst type T (for eksempel 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);
}Implementere metoder på generiske strukturer
Når du implementerer metoder for en generisk struktur, må du angi de generiske typeparameterne etter impl.
Du kan også legge til trait-begrensninger for metoder hvis en metode krever bestemt oppførsel fra de generiske typene.
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 ytelse
En av Rusts styrker er at generiske typer er en abstraksjon uten kostnad. Det betyr at bruk av generiske typer ikke medfører noen ytelsesstraff under kjøring.
Rust oppnår dette gjennom monomorfisering: Ved kompilering genererer kompilatoren spesialiserte versjoner av den generiske koden for hver konkrete type den brukes med. Dermed blir largest<i32> og largest<char> to separate, optimaliserte funksjoner.
Test kunnskapene dine
Hvilke av følgende påstander om generiske typer i Rust er RIKTIGE?
Oppsummering: Kraften i generiske typer
I denne leksjonen har du lært det grunnleggende om å skrive generisk kode i Rust:
- Hva de er: En måte å skrive fleksibel og gjenbrukbar kode på.
- Generiske funksjoner: Bruk av
<T>som typeparametere. - Trait-begrensninger: Angivelse av nødvendige egenskaper med
T: Trait. - Generiske strukturer: Oppretting av datastrukturer som inneholder generiske typer.
- Uten kostnad: Rust kompilerer generiske typer til spesifikk kode, slik at det ikke oppstår noen ytelsesstraff under kjøring.
Generiske typer er en grunnpilar i idiomatisk Rust og muliggjør kraftige, typesikre abstraksjoner!
Lær deg Rust med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 39
- Leksjoner
- 144
Ofte stilte spørsmål
Er leksjonen «Skrive generisk kode i Rust» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær Rust-programmering, inkludert «Skrive generisk kode i Rust», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær Rust-programmering inneholder totalt 3 leksjoner.
Hva lærer jeg i «Skrive generisk kode i Rust»?
Lær å skrive funksjoner og datastrukturer som fungerer med flere typer, slik at koden blir mer gjenbrukbar uten at typesikkerheten svekkes. Du øver på Lær Rust-programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Lær Rust-programmering?
Ingen tidligere erfaring er nødvendig. Lær Rust-programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 3.
Hvor lang tid tar leksjonen «Skrive generisk kode i Rust»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Lær Rust-programmering-leksjonen?
Ja. Alle Lær Rust-programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Skrive generisk kode i Rust
- Definere og implementere traits
- Avansert bruk av traits: tilknyttede typer