Learn Rust Coding · Lekcja

Wyrażenia i instrukcje

Ostatnie wyrażenie

Wyrażenia i instrukcje 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.

Instrukcje a wyrażenia

Rust rozróżnia dwa rodzaje kodu:

Instrukcje wykonują działanie i nie zwracają wartości.
Wyrażenia obliczają wartość.

To rozróżnienie wpływa na sposób, w jaki funkcje zwracają wartości.

fn main() {
    let x = 5;      // a let statement
    let y = x + 1;  // x + 1 is an expression
    println!("{}", y);
}

let jest instrukcją

Wiązanie let jest instrukcją. Nie zwraca wartości, dlatego nie można napisać let a = (let b = 6);.

fn main() {
    let a = 6;
    // let c = (let d = 6); // error: let is not an expression
    println!("{}", a);
}

Wyrażenia obliczają wartości

Działania arytmetyczne, wywołania funkcji i literały są wyrażeniami, ponieważ tworzą wartość.

5
2 + 3
square(4)

fn main() {
    let v = 2 + 3 * 4;
    println!("{}", v);
}

Bloki są wyrażeniami

Blok { ... } sam jest wyrażeniem. Jego wartością jest ostatnie wyrażenie wewnątrz, jeśli nie kończy się ono średnikiem.

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("y is {}", y);
}

Średnik ma znaczenie

Dodanie średnika przekształca wyrażenie w instrukcję i odrzuca jego wartość.

x + 1 — wyrażenie, zwraca wartość.
x + 1; — instrukcja, zwraca ().

fn main() {
    let y = {
        let x = 3;
        x + 1   // no semicolon: this is the block's value
    };
    println!("{}", y);
}

Ostatnie wyrażenie jest zwracane

W funkcji ostatnie wyrażenie bez średnika staje się wartością zwracaną. Jest to idiomatyczny sposób pisania kodu w Rust.

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

fn five() -> i32 {
    5
}

Średnik przerywa zwracanie wartości

Jeśli przypadkowo dodasz średnik do ostatniej linii, funkcja zwróci () zamiast właściwej wartości — to częsty błąd początkujących.

fn main() {
    println!("{}", plus_one(10));
}

fn plus_one(n: i32) -> i32 {
    n + 1   // correct: no semicolon
}

if jako wyrażenie

Ponieważ if jest wyrażeniem, można przypisać jego wynik do zmiennej. Obie gałęzie muszą zwracać ten sam typ.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number is {}", number);
}

loop jako wyrażenie

Pętla loop może zwracać wartość za pomocą break. Wartość umieszczona po break staje się wynikiem pętli.

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("result {}", result);
}

match jako wyrażenie

match również jest wyrażeniem. Każda gałąź tworzy wartość, a wartość dopasowanej gałęzi jest wynikiem.

fn main() {
    let n = 2;
    let label = match n {
        1 => "one",
        2 => "two",
        _ => "many",
    };
    println!("{}", label);
}

Połączenie wszystkiego

Traktowanie bloków i sterowania przepływem jako wyrażeń sprawia, że Rust jest zwięzły: obliczanie i zwracanie wartości odbywa się w jednym płynnym kroku.

fn main() {
    let score = 85;
    let grade = if score >= 90 { 'A' } else if score >= 80 { 'B' } else { 'C' };
    println!("grade {}", grade);
}

Szybkie sprawdzenie

Co dodanie średnika robi z wyrażeniem?

Podsumowanie

Wyrażenia i instrukcje w Rust:

Instrukcje (takie jak let) wykonują działanie, ale nie zwracają wartości.
Wyrażenia obliczają wartość.
Bloki, if, match i loop są wyrażeniami.
Ostatnie wyrażenie bez średnika jest wartością zwracaną.

fn main() {
    let x = { let a = 2; a * a };
    let y = if x > 3 { "big" } else { "small" };
    println!("{} {}", x, y);
}

Często zadawane pytania

Czy lekcja „Wyrażenia i instrukcje” jest bezpłatna?

Tak — pełny tekst „Wyrażenia i instrukcje” 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 „Wyrażenia i instrukcje”?

Ostatnie wyrażenie Ć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 „Wyrażenia i instrukcje”?

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