Elideringsregler
När livstider härleds
Elideringsregler är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Livstider som du inte behöver skriva
Många funktioner tar emot och returnerar referenser utan några livstidsannoteringar, men kompileras ändå. Det beror på livstidelselision: kompilatorn härleder uppenbara livstider åt dig.
Elision är bara en genväg
Elision tar inte bort livstider. Kompilatorn fyller fortfarande i dem i bakgrunden med hjälp av några deterministiska regler. När reglerna täcker ditt fall kan du utelämna annoteringarna.
En funktion med elision
Den här funktionen har inga uttryckliga livstider, men kompilatorn förstår ändå att den returnerade referensen lånar från indata. Reglerna 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: Varje indata får en egen
Den första regeln: varje utelämnad livstid i parametrarna får en separat livstid. Två referensparametrar får två olika livstider.
Regel 2: En indata, en utdata
Den andra regeln: om det finns exakt en livstid för indata tilldelas den alla livstider för utdata. Detta gäller funktioner som first_word, som tar emot och returnerar en referens.
fn trim_start(s: &str) -> &str {
s.trim_start()
}
fn main() {
println!("[{}]", trim_start(" hi"));
}Regel 3: Metoder och &self
Den tredje regeln: om en metod har &self eller &mut self tilldelas selfs livstid till alla livstider för utdata. Därför behöver metoder sällan annoteringar.
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 elision inte fungerar
Om någon livstid för utdata fortfarande är okänd efter att alla tre regler har tillämpats ber kompilatorn dig att annotera den uttryckligen. Funktionen longest är det klassiska fallet: två indata och en tvetydig utdata.
Funktionen longest igen
Två referenser som indata och en referens som utdata: regel 2 gäller inte, eftersom det finns fler än en indata, och det finns inget self. Därför måste du annotera.
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"));
}Flera indata, utdata från self
En metod med flera parametrar får fortfarande sin livstid för utdata från self enligt regel 3, även om andra referensparametrar finns.
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"));
}Varför reglerna finns
Dessa tre regler täcker den överväldigande majoriteten av verklig kod, så de flesta funktioner behöver ingen livstidssyntax alls. Du skriver annoteringar endast när avsikten verkligen är tvetydig.
En snabb checklista
Ställ följande frågor för att avgöra om elision gäller:
- Finns exakt en referens som indata? Då lånas utdata från den.
- Finns en
&self? Då lånas utdata från self. - Annars annoterar du uttryckligen.
Snabbkontroll
Testa din förståelse av elisionsreglerna.
Sammanfattning
Du har lärt dig när livstider härleds:
- Regel 1: varje referens som indata får en egen livstid
- Regel 2: en livstid för indata kopplas till alla utdata
- Regel 3:
&selftillhandahåller livstiden för utdata i metoder - Om utdata fortfarande är tvetydig annoterar du uttryckligen
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Elideringsregler” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Elideringsregler”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Elideringsregler”?
När livstider härleds Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Elideringsregler”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Varför livstider
- Livstidsannoteringar
- Livstider i structar
- Elideringsregler