Learn Rust Coding · Lekcja

Reguły pomijania

Kiedy czasy życia są wnioskowane

Reguły pomijania to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 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.

Czasy życia, których nie zapisujesz

Wiele funkcji przyjmuje i zwraca odwołania bez żadnych adnotacji czasów życia, a mimo to się kompiluje. Dzieje się tak dzięki elizji czasu życia: kompilator sam wnioskuje oczywiste czasy życia.

Elizja to tylko skrót

Elizja nie usuwa czasów życia; kompilator nadal uzupełnia je w tle, korzystając z kilku deterministycznych reguł. Gdy reguły obejmują dany przypadek, można pominąć adnotacje.

Funkcja z pominiętym czasem życia

Ta funkcja nie zawiera jawnych czasów życia, a mimo to kompilator rozumie, że zwracane odwołanie pożycza dane od argumentu wejściowego. Reguły sprawiają, że nie ma tu niejednoznaczności.

fn first_word(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

fn main() {
    let phrase = String::from("rust is fun");
    println!("{}", first_word(&phrase));
}

Reguła 1: każdy argument wejściowy ma własny czas życia

Pierwsza reguła: każdemu pominiętemu czasowi życia w parametrach przypisywany jest odrębny czas życia. Dwa parametry będące odwołaniami otrzymują dwa osobne czasy życia.

Reguła 2: jedno wejście, jedno wyjście

Druga reguła: jeśli istnieje dokładnie jeden wejściowy czas życia, zostaje on przypisany wszystkim wyjściowym czasom życia. Dotyczy to funkcji takich jak first_word, które przyjmują i zwracają jedno odwołanie.

fn trim_start(s: &str) -> &str {
    s.trim_start()
}

fn main() {
    println!("[{}]", trim_start("   hi"));
}

Reguła 3: metody i &self

Trzecia reguła: jeśli metoda ma &self lub &mut self, czas życia self zostaje przypisany wszystkim wyjściowym czasom życia. Dlatego metody rzadko potrzebują adnotacji.

struct Holder { value: String }

impl Holder {
    fn get(&self) -> &str {
        &self.value
    }
}

fn main() {
    let h = Holder { value: String::from("stored") };
    println!("{}", h.get());
}

Gdy elizja nie działa

Jeśli po zastosowaniu wszystkich trzech reguł którykolwiek wyjściowy czas życia nadal jest nieznany, kompilator prosi o jawną adnotację. Klasycznym przykładem jest funkcja longest: dwa argumenty wejściowe i niejednoznaczny wynik.

Funkcja longest raz jeszcze

Dwa odwołania wejściowe i jedno odwołanie wyjściowe: reguła 2 nie ma zastosowania (jest więcej niż jedno wejście), a nie ma też self. Trzeba więc dodać adnotację.

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

Wiele wejść, wynik z self

Metoda z kilkoma parametrami nadal otrzymuje wyjściowy czas życia z self zgodnie z regułą 3, nawet jeśli istnieją inne parametry będące odwołaniami.

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

Dlaczego istnieją te reguły

Te trzy reguły obejmują zdecydowaną większość rzeczywistego kodu, dlatego większość funkcji w ogóle nie potrzebuje składni czasów życia. Adnotacje zapisujesz tylko wtedy, gdy zamiar jest rzeczywiście niejednoznaczny.

Krótka lista kontrolna

Aby ustalić, czy ma zastosowanie elizja, zapytaj:

Czy istnieje dokładnie jedno odwołanie wejściowe? Wynik pożycza dane od niego.
Czy istnieje &self? Wynik pożycza dane od self.
W przeciwnym razie dodaj jawną adnotację.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat reguł elizji.

Podsumowanie

Nauczyłeś się, kiedy czasy życia są wnioskowane:

Reguła 1: każde odwołanie wejściowe otrzymuje własny czas życia
Reguła 2: jeden wejściowy czas życia jest przypisywany wszystkim wyjściom
Reguła 3: &self dostarcza wyjściowy czas życia w metodach
Jeśli wyniki pozostają niejednoznaczne, dodajesz jawną adnotację

Często zadawane pytania

Czy lekcja „Reguły pomijania” jest bezpłatna?

Tak — pełny tekst „Reguły pomijania” 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 „Reguły pomijania”?

Kiedy czasy życia są wnioskowane Ć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 4 z 4.

Ile czasu zajmuje lekcja „Reguły pomijania”?

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