Learn Rust Coding · Lekcja

Result i operator ?

Propagowanie błędów

Lekcja 1 z 413 kroki

Result i operator ? 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.

Typ Result

Result<T, E> reprezentuje operację, która może zakończyć się powodzeniem z Ok(T) lub niepowodzeniem z Err(E). Jest to podstawowy typ Rust do obsługi błędów.

fn main() {
    let parsed: Result<i32, _> = "42".parse::<i32>();
    println!("{:?}", parsed);
}

Dopasowywanie wartości Result

Oba wyniki można jawnie obsłużyć za pomocą match.

fn main() {
    match "oops".parse::<i32>() {
        Ok(n) => println!("got {n}"),
        Err(e) => println!("error: {e}"),
    }
}

Zwracanie wartości Result

Funkcje, które mogą zakończyć się niepowodzeniem, zwracają Result, pozwalając wywołującemu zdecydować, jak obsłużyć błędy.

fn halve(n: i32) -> Result<i32, String> {
    if n % 2 == 0 {
        Ok(n / 2)
    } else {
        Err("odd number".to_string())
    }
}

fn main() {
    println!("{:?}", halve(10));
    println!("{:?}", halve(7));
}

Operator ?

Operator ? rozwija wartość Ok albo wcześnie zwraca Err z funkcji. Zastępuje rozwlekły kod z match i return.

fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    println!("{:?}", double_str("21"));
    println!("{:?}", double_str("x"));
}

Łączenie za pomocą ?

Wiele kroków mogących zakończyć się niepowodzeniem można czytelnie połączyć za pomocą ?; pierwszy błąd przerywa wykonywanie pozostałych.

fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
    let x = a.parse::<i32>()?;
    let y = b.parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_two("3", "4"));
}

? w main

main może zwracać Result, więc operator ? działa również w niej. Zwrócone Err kończy program kodem wyjścia różnym od zera.

fn main() -> Result<(), std::num::ParseIntError> {
    let n: i32 = "100".parse()?;
    println!("parsed {n}");
    Ok(())
}

Przydatne metody Result

Przydatne kombinatory:

unwrap_or(default) — wartość lub wartość zastępcza
map — przekształca wartość Ok
map_err — przekształca błąd
is_ok / is_err — sprawdza wariant

fn main() {
    let n = "x".parse::<i32>().unwrap_or(-1);
    println!("{n}");
}

Konwersja Option do Result

Przekształć Option w Result za pomocą ok_or, aby operator ? mógł propagować znaczący błąd.

fn first_char(s: &str) -> Result<char, String> {
    let c = s.chars().next().ok_or("empty string".to_string())?;
    Ok(c)
}

fn main() {
    println!("{:?}", first_char("hi"));
    println!("{:?}", first_char(""));
}

Jak ? konwertuje błędy

Gdy typy błędów się różnią, operator ? wywołuje From::from, aby przekonwertować błąd na zadeklarowany typ błędu funkcji. Umożliwia to wygodną obsługę błędów w wielu warstwach.

Unikanie unwrap w kodzie produkcyjnym

unwrap i expect wywołują panikę dla wartości Err. Są odpowiednie w przykładach i testach, ale w rzeczywistym kodzie należy preferować ? lub jawną obsługę, aby błędy można było odzyskać.

Łączenie za pomocą and_then

and_then uruchamia kolejny krok mogący zakończyć się niepowodzeniem tylko wtedy, gdy poprzedni zakończył się powodzeniem, przekazując dalej wartość.

fn main() {
    let result = "8"
        .parse::<i32>()
        .and_then(|n| Ok(n * 2));
    println!("{:?}", result);
}

Szybkie sprawdzenie

Co robi operator ? zastosowany do wartości Result, która ma wariant Err?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznał(a) Pan/Pani obsługę błędów opartą na typie Result:

Result<T, E> reprezentuje powodzenie lub niepowodzenie
? wyodrębnia wartość Ok albo wcześnie zwraca Err
? działa w funkcjach i w main, które zwracają Result
Kombinatory, takie jak map, map_err, unwrap_or i ok_or, ułatwiają pracę
Należy unikać unwrap w kodzie produkcyjnym

Bezpłatny start

Ucz się Rust dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 144

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Result i operator ?” jest bezpłatna?

Tak — pełny tekst „Result i operator ?” 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 „Result i operator ?”?

Propagowanie błędów Ć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 „Result i operator ?”?

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