Learn Rust Coding · Lekcja

Po co czasy życia

Zapobieganie wiszącym referencjom

Po co czasy życia to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Referencje muszą pozostać prawidłowe

Referencja pożycza dane, których nie posiada. Rust musi zagwarantować, że dane będą istnieć co najmniej tak długo jak referencja. Czasy życia służą kompilatorowi do śledzenia tej zależności.

Ich zadaniem jest zapobieganie dangling references.

Czym jest dangling reference?

Dangling reference wskazuje pamięć, która została zwolniona. W językach bez mechanizmów kontrolnych użycie takiej referencji powoduje awarie lub błędy bezpieczeństwa. Rust odmawia kompilacji takiego kodu.

Kontroler pożyczania w działaniu

Ten kod utworzyłby referencję do wartości, której zakres ważności dobiega końca. Rust odrzuca go w czasie kompilacji. Czasy życia są regułą, na podstawie której podejmuje tę decyzję.

fn main() {
    let r;
    {
        let x = 5;
        r = &x;
        println!("inside: {}", r);
    }
    // using r here would be a dangling reference
    println!("done");
}

Zakresy definiują czasy życia

Czas życia wartości to okres, w którym jest ona prawidłowa, zwykle odpowiadający jej zakresowi. Referencja nie może żyć dłużej niż wskazywana przez nią wartość.

Tutaj zarówno x, jak i referencja żyją w tym samym zakresie, więc wszystko jest w porządku.

fn main() {
    let x = 5;
    let r = &x;
    println!("x is {}, r is {}", x, r);
}

Zwracanie referencji

Funkcja zwracająca referencję musi zwrócić taką, która pozostanie prawidłowa dla kodu wywołującego. Nie można zwrócić referencji do zmiennej lokalnej, ponieważ przestaje ona istnieć po zakończeniu funkcji.

Zwracanie pożyczki z argumentu

Można natomiast zwrócić referencję pożyczającą dane z argumentu. Wynik jest prawidłowy tak długo, jak długo prawidłowy jest ten argument. Dokładnie to opisują adnotacje czasów życia.

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));
}

Czasy życia istnieją tylko w czasie kompilacji

Czasy życia są wyłącznie pojęciem używanym w czasie kompilacji. Nie powodują żadnego kosztu w czasie działania i istnieją tylko po to, aby kontroler pożyczania mógł sprawdzać bezpieczeństwo pamięci.

Własność i czasy życia razem

Własność określa, kto zwalnia wartość, a czasy życia — jak długo mogą istnieć pożyczki tej wartości. Razem pozwalają Rustowi zagwarantować bezpieczeństwo bez modułu odśmiecania.

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);
}

Dlaczego nazwy pojawiają się w sygnaturach

Gdy funkcja przyjmuje wiele referencji, kompilator czasami nie potrafi ustalić zależności między ich czasami życia. Wtedy dodaje się adnotacje czasów życia, aby wyjaśnić te zależności.

Następna lekcja omawia tę składnię.

Korzyść

Dzięki czasom życia cała kategoria błędów — użycie po zwolnieniu, dangling pointers, unieważnienie iteratora — po prostu nie może zostać skompilowana. Otrzymujesz szybkość porównywalną z C wraz z bezpieczeństwem pamięci.

Model mentalny

Pomyśl o czasie życia jak o etykiecie określającej, jak długo dane istnieją. Referencja niesie ograniczenie: jest prawidłowa tylko tak długo, jak długo istnieje jej źródło. Kontroler pożyczania egzekwuje tę zasadę.

Szybki sprawdzian

Sprawdź, jak dobrze rozumiesz, po co istnieją czasy życia.

Podsumowanie

Omówiono, po co istnieją czasy życia:

Referencje nie mogą żyć dłużej niż pożyczane przez nie dane
Czasy życia zapobiegają dangling references w czasie kompilacji
Istnieją tylko w czasie kompilacji i nie powodują kosztu w czasie działania
Współpracują z własnością, zapewniając bezpieczeństwo pamięci bez modułu odśmiecania

Często zadawane pytania

Czy lekcja „Po co czasy życia” jest bezpłatna?

Tak — pełny tekst „Po co czasy życia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Po co czasy życia”?

Zapobieganie wiszącym referencjom Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Po co czasy życia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding