Regler for elision
Når lifetimes udledes
Regler for elision er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 4 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.
Levetider, du ikke selv skriver
Mange funktioner tager imod og returnerer referencer uden levetidsannoteringer, men kan alligevel kompileres. Det skyldes udeladelse af levetider: Compileren udleder de oplagte levetider for dig.
Udeladelse er blot en genvej
Udeladelse fjerner ikke levetider; compileren udfylder dem stadig i baggrunden ved hjælp af nogle få deterministiske regler. Når reglerne dækker dit tilfælde, kan du udelade annoteringerne.
En funktion med udeladte levetider
Denne funktion har ingen eksplicitte levetider, men compileren forstår alligevel, at den returnerede reference låner fra inputtet. Reglerne gør det entydigt.
fn first_word(s: &str) -> &str {
s.split(' ').next().unwrap_or("")
}
fn main() {
let phrase = String::from("rust is fun");
println!("{}", first_word(&phrase));
}Regel 1: Hvert input får sin egen
Den første regel: Hver udeladt levetid i parametrene får en særskilt levetid. To referenceparametre får to separate levetider.
Regel 2: Ét input, ét output
Den anden regel: Hvis der præcis er én inputlevetid, tildeles den til alle outputlevetider. Det dækker funktioner som first_word, der tager imod og returnerer én reference.
fn trim_start(s: &str) -> &str {
s.trim_start()
}
fn main() {
println!("[{}]", trim_start(" hi"));
}Regel 3: Metoder og &self
Den tredje regel: Hvis en metode har &self eller &mut self, tildeles selfs levetid til alle outputlevetider. Derfor har metoder sjældent brug for annoteringer.
struct Holder { value: String }
impl Holder {
fn get(&self) -> &str {
&self.value
}
}
fn main() {
let h = Holder { value: String::from("stored") };
println!("{}", h.get());
}Når udeladelse mislykkes
Hvis en outputlevetid stadig er ukendt efter anvendelsen af alle tre regler, beder compileren dig om at annotere den eksplicit. Funktionen longest er det klassiske tilfælde: to input, tvetydigt output.
Funktionen longest igen
To referenceinput og ét referenceresultat: Regel 2 gælder ikke (der er mere end ét input), og der er ingen self. Derfor skal du annotere eksplicit.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
fn main() {
println!("{}", longest("abcd", "ab"));
}Flere input, output fra self
En metode med flere parametre får stadig sin outputlevetid fra self efter regel 3, selvom der findes andre referenceparametre.
struct Doc { body: String }
impl Doc {
fn announce(&self, _note: &str) -> &str {
&self.body
}
}
fn main() {
let d = Doc { body: String::from("content") };
println!("{}", d.announce("ping"));
}Hvorfor reglerne findes
Disse tre regler dækker langt størstedelen af den virkelige kode, så de fleste funktioner slet ikke har brug for levetidssyntaks. Du skriver kun annoteringer, når hensigten reelt er tvetydig.
En hurtig tjekliste
For at afgøre, om udeladelse gælder, kan du spørge:
- Er der præcis én inputreference? Output låner fra den.
- Er der en
&self? Output låner fra self. - Ellers skal du annotere eksplicit.
Hurtigt tjek
Test din forståelse af reglerne for udeladelse.
Opsummering
Du har lært, hvornår levetider udledes:
- Regel 1: Hver inputreference får sin egen levetid
- Regel 2: Én inputlevetid knyttes til alle output
- Regel 3:
&selfleverer outputlevetiden i metoder - Hvis output stadig er tvetydigt, skal du annotere eksplicit
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 “Regler for elision” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Regler for elision”, 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 “Regler for elision”?
Når lifetimes udledes 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 4 af 4.
Hvor lang tid tager lektionen “Regler for elision”?
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
- Hvorfor lifetimes
- Lifetime-annoteringer
- Lifetimes i structs
- Regler for elision