Perché le lifetime
Prevenzione dei riferimenti dangling
Perché le lifetime è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
I riferimenti devono rimanere validi
Un riferimento prende in prestito dati che non possiede. Rust deve garantire che i dati vivano almeno quanto il riferimento. I lifetime sono il meccanismo con cui il compilatore tiene traccia di questo aspetto.
Il loro scopo è impedire i riferimenti pendenti.
Che cos'è un riferimento pendente?
Un riferimento pendente punta a una porzione di memoria che è stata liberata. Nei linguaggi privi di controlli, usarne uno provoca arresti anomali o problemi di sicurezza. Rust rifiuta di compilare questo tipo di codice.
Il borrow checker in azione
Questo codice creerebbe un riferimento a un valore che esce dall'ambito. Rust lo rifiuta in fase di compilazione. I lifetime sono la regola che usa per decidere.
fn main() {
let r;
{
let x = 5;
r = &x;
println!("inside: {}", r);
}
// using r here would be a dangling reference
println!("done");
}Gli ambiti definiscono i lifetime
Il lifetime di un valore è l'intervallo durante il quale è valido, in genere il suo ambito. Un riferimento non deve sopravvivere al valore a cui punta.
Qui sia x sia il riferimento vivono nello stesso ambito, quindi non ci sono problemi.
fn main() {
let x = 5;
let r = &x;
println!("x is {}, r is {}", x, r);
}Restituire riferimenti
Una funzione che restituisce un riferimento deve restituirne uno che rimanga valido per il chiamante. Non è possibile restituire un riferimento a una variabile locale, perché questa viene eliminata quando termina la funzione.
Restituire un prestito di un input
È invece possibile restituire un riferimento che prende in prestito un input. Il risultato è valido finché lo è quell'input. È esattamente ciò che descrivono le annotazioni dei lifetime.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[..i];
}
}
s
}
fn main() {
let sentence = String::from("hello world");
println!("{}", first_word(&sentence));
}I lifetime esistono solo in fase di compilazione
I lifetime sono un concetto esclusivamente legato alla fase di compilazione. Non aggiungono alcun costo in fase di esecuzione ed esistono solo per permettere al borrow checker di verificare la sicurezza della memoria.
Ownership e lifetime insieme
L'ownership stabilisce chi libera un valore; i lifetime stabiliscono per quanto tempo possono vivere i prestiti di quel valore. Insieme permettono a Rust di garantire la sicurezza senza un garbage collector.
fn main() {
let data = vec![1, 2, 3];
let view = &data[0..2];
println!("{:?}", view);
// data still owns the vector; view just borrows part of it
println!("{:?}", data);
}Perché i nomi compaiono nelle firme
Quando una funzione accetta più riferimenti, a volte il compilatore non riesce a capire quale relazione esista tra i loro lifetime. È quindi necessario aggiungere annotazioni dei lifetime per chiarire queste relazioni.
La sintassi verrà trattata nella prossima lezione.
Il vantaggio
Grazie ai lifetime, un'intera categoria di bug — use-after-free, puntatori pendenti, invalidazione degli iteratori — semplicemente non può essere compilata. Si ottengono prestazioni simili a C con la sicurezza della memoria.
Modello mentale
Consideri un lifetime come un'etichetta sulla durata della vita dei dati. Un riferimento porta con sé il vincolo: è valido solo finché è valido il proprio dato sorgente. Il borrow checker fa rispettare questo vincolo.
Verifica rapida
Metta alla prova la sua comprensione del motivo per cui esistono i lifetime.
Riepilogo
Ha imparato perché esistono i lifetime:
- I riferimenti non devono sopravvivere ai dati che prendono in prestito
- I lifetime impediscono i riferimenti pendenti in fase di compilazione
- Esistono solo in fase di compilazione e non hanno alcun costo in fase di esecuzione
- Collaborano con l'ownership per garantire la sicurezza della memoria senza un GC
Domande Frequenti
La lezione «Perché le lifetime» è gratuita?
Sì — il testo completo di «Perché le lifetime» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Perché le lifetime»?
Prevenzione dei riferimenti dangling Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Perché le lifetime»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché le lifetime
- Annotazioni delle lifetime
- Lifetime nelle struct
- Regole di elisione