Learn Rust Coding · Lekcja

Adnotacje czasu życia

Nazywanie czasów życia

Adnotacje czasu życia to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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.

Nazywanie czasu życia

Adnotacja czasu życia to nazwa zaczynająca się od apostrofu, na przykład 'a. Nie zmienia ona tego, jak długo coś istnieje; opisuje zależności między czasami życia referencji.

Gdzie umieszcza się adnotacje

Parametry czasów życia deklaruje się w nawiasach ostrych po nazwie funkcji, a następnie używa się ich przy typach referencji, tak jak parametrów typów generycznych.

Składnia: fn name<'a>(x: &'a T) -> &'a T.

Klasyczna funkcja longest

Funkcja zwracająca jedną z dwóch referencji wymaga adnotacji. 'a oznacza, że wynik żyje tak długo, jak krótsza z dwóch referencji wejściowych.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let a = String::from("long string");
    let b = String::from("short");
    println!("{}", longest(&a, &b));
}

Co oznacza tutaj 'a

Adnotacja informuje kompilator, że zwrócona referencja jest prawidłowa tylko wtedy, gdy obie referencje wejściowe są prawidłowe. Następnie kompilator sprawdza każde miejsce wywołania względem tego kontraktu.

Dlaczego jest to potrzebne

Bez adnotacji kompilator nie wie, czy wynik pożycza dane z x, czy z y. Nazwa czasu życia łączy je ze sobą, dzięki czemu kontroler pożyczania może przeanalizować wynik.

Różne czasy życia

Gdy referencje nie są ze sobą powiązane, nadaj im różne nazwy czasów życia. Tutaj zwracane jest tylko x, więc dla wyniku znaczenie ma tylko jego czas życia.

fn first<'a, 'b>(x: &'a str, _y: &'b str) -> &'a str {
    x
}

fn main() {
    let a = String::from("keep me");
    let b = String::from("ignore");
    println!("{}", first(&a, &b));
}

Czasy życia nie przedłużają istnienia danych

Adnotacje nigdy nie sprawiają, że dane żyją dłużej. Określają tylko ograniczenia, które kompilator musi sprawdzić. Jeśli wartość przestanie istnieć zbyt wcześnie, kod się nie skompiluje niezależnie od adnotacji.

Prawidłowe wywołanie

Jeśli obie referencje wejściowe będą istnieć dłużej niż wynik jest używany, wywołanie zostanie zaakceptowane. Tutaj oba napisy istnieją aż do instrukcji wypisywania, więc wszystko jest w porządku.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let a = String::from("abcdef");
    let result;
    {
        let b = String::from("xy");
        result = longest(&a, &b);
        println!("chosen: {}", result);
    }
}

Czasy życia i typy generyczne

Parametry czasów życia i typów mogą występować razem. Czasy życia umieszcza się jako pierwsze w nawiasach ostrych.

use std::fmt::Display;

fn announce<'a, T: Display>(text: &'a str, value: T) -> &'a str {
    println!("value is {}", value);
    text
}

fn main() {
    let msg = String::from("hello");
    println!("{}", announce(&msg, 42));
}

Czas życia 'static

'static to specjalny czas życia oznaczający, że referencja może istnieć przez cały czas działania programu. Literały łańcuchowe mają ten czas życia, ponieważ są zapisane w pliku binarnym.

fn motto() -> &'static str {
    "fearless concurrency"
}

fn main() {
    println!("{}", motto());
}

Odczytywanie adnotacji

Odczytaj &'a str jako odwołanie do napisu ważne przez czas życia 'a. Gdy dwa parametry współdzielą 'a, kompilator wiąże ich czasy życia z tym, który przy danym wywołaniu jest krótszy.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat adnotacji czasów życia.

Podsumowanie

Nauczyłeś się nazywać czasy życia:

Czasy życia mają nazwy takie jak 'a, deklarowane w nawiasach ostrych
Wspólne nazwy wyrażają zależność między odwołaniami (np. wynik jest powiązany z argumentami wejściowymi)
Adnotacje opisują czasy życia, ale ich nie wydłużają
'static oznacza ważność przez cały czas działania programu

Często zadawane pytania

Czy lekcja „Adnotacje czasu życia” jest bezpłatna?

Tak — pełny tekst „Adnotacje czasu ż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 „Adnotacje czasu życia”?

Nazywanie czasów życia Ć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 2 z 4.

Ile czasu zajmuje lekcja „Adnotacje czasu ż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