Learn Rust Coding · Lekcja

let i mutowalność

Powiązania i mutowalność

let i mutowalność 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.

Powiązywanie wartości za pomocą let

W języku Rust zmienną tworzy się za pomocą słowa kluczowego let. W ten sposób powiązuje się nazwę z wartością.

Domyślnie każde powiązanie jest niezmienne — po przypisaniu wartości nie można jej zmienić.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Domyślna niezmienność

Rust celowo zapewnia niezmienność zmiennych. Zapobiega to przypadkowym zmianom i ułatwia analizowanie kodu.

Próba ponownego przypisania wartości do niezmiennego powiązania powoduje błąd kompilacji, a nie awarię w czasie działania.

let x = 5;, a następnie x = 6; — taki kod się nie skompiluje.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Uczynienie zmiennych modyfikowalnymi

Gdy trzeba zmienić wartość, należy dodać słowo kluczowe mut. Oznacza ono powiązanie jako modyfikowalne.

Teraz można przypisywać mu nowe wartości dowolną liczbę razy.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Wnioskowanie typów

Rust zazwyczaj rozpoznaje typ zmiennej na podstawie jej wartości. Nazywa się to wnioskowaniem typu.

let x = 5; automatycznie nadaje x typ i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Adnotacje typów

Typ można także określić jawnie za pomocą dwukropka i nazwy typu. Jest to adnotacja typu.

Adnotacje są przydatne, gdy kompilator nie może wywnioskować typu, lub gdy zależy nam na większej czytelności.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Stałe

const jest zawsze niezmienne i musi mieć adnotację typu. Jego wartość musi być znana w czasie kompilacji.

Zgodnie z konwencją stałe zapisuje się w formacie SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const a let

Najważniejsze różnice między const a let:

const nigdy nie może być mut.
const wymaga adnotacji typu.
const musi być stałym wyrażeniem obliczanym w czasie kompilacji.
Wartości let mogą być obliczane w czasie działania.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Modyfikowanie w pętli

Zmienne modyfikowalne są często używane w pętlach, w których wartość narasta z upływem czasu.

W tym przykładzie sumujemy liczby za pomocą akumulatora oznaczonego mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Podkreślenie dla nieużywanych wartości

Jeśli powiąże Pan wartość, ale nigdy jej nie użyje, Rust wyświetli ostrzeżenie. Aby je wyciszyć, należy poprzedzić nazwę podkreśleniem.

let _unused = 10; informuje kompilator, że jest to działanie zamierzone.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Wiele powiązań

Można zadeklarować kilka zmiennych w osobnych wierszach, używając dla każdej własnego let.

Każde powiązanie jest niezależne i niezmienne, chyba że zostanie oznaczone jako mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Dlaczego niezmienność pomaga

Niezmienność to funkcja bezpieczeństwa. Gdy kompilator wie, że wartości nie można zmienić, może zapewnić silniejsze gwarancje i zapobiec całym klasom błędów.

Po mut należy sięgać tylko wtedy, gdy modyfikowanie wartości jest rzeczywiście potrzebne.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Szybki test

Jakie słowo kluczowe sprawia, że zmienna w języku Rust może zmieniać wartość?

Podsumowanie

Poznał Pan podstawy powiązań w języku Rust:

let wiąże nazwę z wartością, domyślnie niezmienną.
mut sprawia, że powiązanie jest modyfikowalne.
Rust wnioskuje typy, ale można dodać adnotacje za pomocą :.
const jest obliczane w czasie kompilacji, zawsze niezmienne i wymaga określenia typu.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Często zadawane pytania

Czy lekcja „let i mutowalność” jest bezpłatna?

Tak — pełny tekst „let i mutowalność” 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 „let i mutowalność”?

Powiązania i mutowalność Ć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 „let i mutowalność”?

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