Learn Rust Coding · Lekcja

Czasy życia w strukturach

Pożyczone pola

Czasy życia w strukturach to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 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.

Struktury mogą pożyczać dane

Większość struktur jest właścicielem swoich danych. Struktura może jednak również przechowywać odwołanie do danych, których nie posiada. W takim przypadku struktura potrzebuje parametru czasu życia.

Gwarantuje to, że struktura nigdy nie przetrwa pożyczonych danych.

Deklarowanie czasu życia w strukturze

Dodaj czas życia w nawiasach ostrych po nazwie struktury, a następnie użyj go przy polu będącym odwołaniem. Oznacza to, że struktura nie może przetrwać tego odwołania.

struct Excerpt<'a> {
    text: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first = novel.split('.').next().unwrap();
    let e = Excerpt { text: first };
    println!("{}", e.text);
}

Dodawane ograniczenie

Adnotacja oznacza, że instancja Excerpt jest ważna tylko wtedy, gdy żyje napis, z którego pożycza dane. Kompilator egzekwuje to wszędzie tam, gdzie struktura jest używana.

Metody struktur pożyczających dane

Metody takiej struktury również zawierają czas życia w nagłówku impl. Często można pominąć czasy życia w treści metody dzięki elizji (omówionej w następnej lekcji).

struct Excerpt<'a> { text: &'a str }

impl<'a> Excerpt<'a> {
    fn announce(&self) -> &str {
        println!("Attention!");
        self.text
    }
}

fn main() {
    let s = String::from("hello world");
    let e = Excerpt { text: &s };
    println!("{}", e.announce());
}

Dlaczego po prostu nie posiadać danych?

Posiadanie danych (z użyciem String) jest prostsze i zazwyczaj zalecane. Pożyczanie pozwala uniknąć kopiowania dużych ilości danych i przydaje się w parserach oraz widokach operujących na istniejących buforach.

Po czasy życia w strukturach sięgaj tylko wtedy, gdy pożyczanie przynosi korzyści.

Przykład widoku parsera

Klasycznym zastosowaniem jest struktura przechowująca wycinki z napisu źródłowego. Odczytuje ona oryginalny bufor bez kopiowania.

struct Token<'a> {
    word: &'a str,
}

fn main() {
    let line = String::from("let x = 5");
    let tokens: Vec<Token> = line.split_whitespace().map(|w| Token { word: w }).collect();
    for t in &tokens {
        println!("token: {}", t.word);
    }
}

Wiele pól będących odwołaniami

Struktura może przechowywać kilka odwołań. Mogą one współdzielić jeden czas życia albo używać różnych czasów życia, zależnie od tego, jak ma się do siebie ich ważność.

struct Pair<'a> {
    left: &'a str,
    right: &'a str,
}

fn main() {
    let a = String::from("foo");
    let b = String::from("bar");
    let p = Pair { left: &a, right: &b };
    println!("{} {}", p.left, p.right);
}

Błąd wiszącej struktury

Jeśli pożyczone dane zostaną usunięte, gdy struktura nadal istnieje, kompilator odrzuci taki kod. To parametr czasu życia umożliwia przeprowadzenie tego sprawdzenia.

Zwracanie struktur pożyczających dane

Funkcja tworząca taką strukturę wiąże czas życia struktury z jej argumentem wejściowym. Struktura nie może przetrwać danych przekazanych do funkcji.

struct Wrap<'a> { inner: &'a str }

fn wrap<'a>(s: &'a str) -> Wrap<'a> {
    Wrap { inner: s }
}

fn main() {
    let text = String::from("wrapped");
    let w = wrap(&text);
    println!("{}", w.inner);
}

Kompromis: posiadanie a pożyczanie

Szybki przewodnik:

Potrzebujesz niezależnie zachować dane? Bądź ich właścicielem (String, Vec).
Potrzebujesz krótkotrwałego widoku istniejących danych? Pożycz je, używając czasu życia.

Model mentalny

Struktura z 'a przypomina karteczkę przyklejoną do cudzego notesu: ma znaczenie tylko wtedy, gdy ten notes nadal istnieje. Rust pilnuje, aby nigdy nie odczytać karteczki z notesu, którego już nie ma.

Szybkie sprawdzenie

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

Podsumowanie

Nauczyłeś się używać czasów życia w strukturach:

Struktura przechowująca odwołanie potrzebuje parametru czasu życia
Czas życia wiąże ważność struktury z pożyczonymi danymi
Metody zawierają czas życia w nagłówku impl
Preferuj posiadanie danych, chyba że pożyczanie pozwala uniknąć istotnego kopiowania

Często zadawane pytania

Czy lekcja „Czasy życia w strukturach” jest bezpłatna?

Tak — pełny tekst „Czasy życia w strukturach” 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 „Czasy życia w strukturach”?

Pożyczone pola Ć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 3 z 4.

Ile czasu zajmuje lekcja „Czasy życia w strukturach”?

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