Lifetimes til sikre referencer
Fordyb Dem i lifetimes, Rusts mekanisme til at sikre, at referencer altid er gyldige, og forhindre dangling pointers på kompileringstidspunktet.
Lifetimes til sikre referencer er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 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 levetider er vigtige
Rusts regler for ejerskab og lån forhindrer mange almindelige hukommelsesfejl. Men der er endnu et sikkerhedslag: levetider.
Levetider sikrer, at referencer i din kode altid peger på gyldige data. De løser problemet med hængende referencer, hvor en reference kan pege på hukommelse, der allerede er frigivet.
Risikoen ved hængende pointere
Forestil dig et scenarie, hvor en funktion opretter data, returnerer en reference til dem, og dataene derefter ødelægges, når funktionen afsluttes. Den returnerede reference ville så pege på ugyldig hukommelse.
Rust bruger levetider til at forhindre dette på kompileringstidspunktet. Den kontrollerer, at enhver reference, du bruger, forbliver gyldig, så længe du har brug for den, og sikrer dermed sikker hukommelsesbrug.
Rust udleder levetider
Du behøver ikke altid skrive eksplicitte levetidsannoteringer. Rust har et sæt regler for udeladelse af levetider, som lader compileren udlede levetider i almindelige mønstre.
I en funktion med én inputreference tildeles dens levetid for eksempel ofte automatisk til outputreferencen. Det holder din kode mere overskuelig!
Hvornår skal du bruge annoteringer
Når Rust ikke kan udlede levetiderne, skal du angive dem eksplicit. Det fortæller compileren, hvordan levetiderne for forskellige referencer hænger sammen.
Syntaksen for en levetidsannotering er en apostrof efterfulgt af et lille bogstav, som i 'a. Det er en generisk parameter for levetider, ikke en bestemt varighed.
Levetidsparametre for funktioner
Når en funktion tager flere referencer og returnerer én, skal Rust vide, hvilken inputreferences levetid outputreferencen skal have. Det sikrer, at den returnerede reference altid er gyldig.
Syntaksen <'a> erklærer en generisk levetidsparameter. Lad os se på et eksempel:
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is: {}", result);
}Levetiden 'static
Levetiden 'static er et særtilfælde. Den angiver, at en reference kan leve i hele programmets varighed.
Strengliteraler (f.eks. "hello world") har levetiden 'static, fordi de gemmes direkte i programmets binærfil og er tilgængelige under hele kørselstiden.
fn main() {
// 'static lifetime for a string literal
let s: &'static str = "I live for the entire program!";
println!("{}", s);
// This is also implicitly 'static
let another_s = "Hello from static land!";
println!("{}", another_s);
}Strukturer, der indeholder referencer
Hvis en struktur indeholder en reference, skal du tilføje en levetidsannotering til strukturens definition. Det sikrer, at ingen instans af strukturen lever længere end de data, dens referencer peger på.
Strukturens levetidsparameter fortæller Rust, at alle referencer i den skal have mindst denne levetid.
struct ImportantExcerpt<'a> {
part: &'a str,
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().expect("Could not find a '.'");
let i = ImportantExcerpt {
part: first_sentence,
};
println!("Excerpt part: {}", i.part);
}Levetider med generiske parametre
Levetider er en form for generiske parametre! Du kan kombinere dem med typeparametre for at oprette fleksible og sikre datastrukturer eller funktioner.
En struktur kan for eksempel indeholde referencer til generiske typer, hvor alle er begrænset af én levetidsparameter. Det sikrer, at komplekse datarelationer forbliver gyldige.
Afkodning af compilerfejl
Når du første gang møder levetidsfejl, kan de virke skræmmende. Den mest almindelige fejl er "borrow might not live long enough".
Det betyder som regel, at du forsøger at bruge en reference, efter at de data, den peger på, er blevet frigivet, eller at Rust ikke kan bevise, at den er gyldig. Når du forstår disse meddelelser, bliver det lettere at tilpasse dine levetidsannoteringer.
Hurtigt tjek: Levetider
Hvilket af følgende beskriver bedst det grundlæggende problem, som Rusts eksplicitte levetidsannoteringer skal løse?
Levetider: Sikkerhed på kompileringstidspunktet
Du har lært, at levetider er en afgørende del af Rusts garantier for sikker hukommelsesbrug. De forhindrer hængende referencer ved at sikre, at alle referencer er gyldige under hele deres anvendelse.
- Rust udleder ofte levetider ved hjælp af regler for udeladelse.
- Du bruger eksplicitte annoteringer som
'a, når udledning ikke er mulig. - Levetider er afgørende for funktioner, der returnerer referencer, og for strukturer, der indeholder referencer.
- Den særlige levetid
'staticvarer under hele programmets varighed.
At mestre levetider er nøglen til at skrive robust Rust-kode!
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 “Lifetimes til sikre referencer” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Lifetimes til sikre referencer”, 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 “Lifetimes til sikre referencer”?
Fordyb Dem i lifetimes, Rusts mekanisme til at sikre, at referencer altid er gyldige, og forhindre dangling pointers på kompileringstidspunktet. 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 3.
Hvor lang tid tager lektionen “Lifetimes til sikre referencer”?
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
- Forstå Rusts ejerskabsmodel
- Referencer og borrowing forklaret
- Lifetimes til sikre referencer