Learn Rust Coding · Lekcja

Przesłanianie

Ponowne wiązanie zmiennych

Przesłanianie 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.

Czym jest przesłanianie?

Przesłanianie oznacza zadeklarowanie nowej zmiennej o tej samej nazwie co wcześniejsza zmienna. Nowe wiązanie „przesłania” stare.

Robi się to, ponownie używając let z tą samą nazwą.

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("x is {}", x);
}

Przesłanianie to nie mutacja

Przesłanianie tworzy zupełnie nową zmienną. Różni się to od mut, które ponownie wykorzystuje tę samą zmienną.

Ponieważ każde let tworzy nowe wiązanie, wartości mogą mieć nawet różne typy.

fn main() {
    let y = 10;        // immutable
    let y = y + 5;     // new binding, also immutable
    println!("y is {}", y);
}

Zmiana typów za pomocą przesłaniania

Potężnym zastosowaniem przesłaniania jest ponowne użycie nazwy przy jednoczesnej zmianie typu.

W tym przypadku łańcuch znaków jest analizowany jako liczba pod tą samą nazwą.

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("count is {}", spaces);
}

Dlaczego mut nie może zmienić typu

Za pomocą mut można zmienić wartość, ale nie typ.

Poniższy kod nie skompiluje się:

let mut spaces = " ";
spaces = spaces.len(); — błąd niezgodności typów.

Przesłanianie rozwiązuje ten problem, ponieważ tworzy nową zmienną.

fn main() {
    let mut count = 3;
    count = 4; // ok, same type
    println!("{}", count);
}

Przesłanianie w zagnieżdżonych zakresach

Zmienna może zostać przesłonięta wewnątrz zagnieżdżonego bloku. Gdy blok się kończy, ponownie widoczne jest zewnętrzne wiązanie.

fn main() {
    let n = 1;
    {
        let n = n * 10;
        println!("inner {}", n);
    }
    println!("outer {}", n);
}

Przekształcanie krok po kroku

Przesłanianie pozwala przekształcać wartość w kilku krokach, zachowując jedną czytelną nazwę.

fn main() {
    let input = "42";
    let input: i32 = input.trim().parse().unwrap();
    let input = input * 2;
    println!("result {}", input);
}

Przesłanianie zachowuje niezmienność

Każde przesłonięte wiązanie pozostaje niezmienne. Po przekształceniu zachowujesz bezpieczeństwo wynikające z niezmienności, bez wymyślania nowych nazw, takich jak x2 lub x_temp.

fn main() {
    let price = 100;
    let price = price - 20;   // discount applied
    let price = price + 5;    // shipping added
    println!("final price {}", price);
}

Przesłanianie z inną logiką

Nową wartość można obliczyć w dowolny sposób, także za pomocą wywołań funkcji lub wyrażeń.

fn main() {
    let text = "hello";
    let text = text.to_uppercase();
    println!("{}", text);
}

Unikanie nieporozumień

Przesłanianie jest przydatne, ale jego nadmierne używanie może dezorientować czytelników. Używaj go, gdy każdy krok jest wyraźnym przekształceniem tego samego pojęcia, a nie tylko po to, by losowo ponownie wykorzystywać nazwy.

fn main() {
    let raw = "  Rust  ";
    let raw = raw.trim();      // clean version
    println!("[{}]", raw);
}

Podsumowanie: przesłanianie a ponowne przypisanie

Istnieją dwa sposoby nadania nazwie nowej wartości:

Przesłanianie: ponowne użycie let x = ...; — nowa zmienna, możliwość zmiany typu, pozostaje niezmienna.
Ponowne przypisanie: x = ...; z użyciem mut — ta sama zmienna, wymagany ten sam typ.

fn main() {
    let val = "7";
    let val: i32 = val.parse().unwrap(); // shadow + type change
    let mut val = val;
    val += 1;                            // reassign, same type
    println!("{}", val);
}

Praktyczny przykład

Odczytywanie i konwertowanie danych użytkownika to klasyczny przypadek użycia przesłaniania: można zachować znaczącą nazwę age, gdy typ zmienia się z tekstu na liczbę.

fn main() {
    let age = "25";
    let age: u32 = age.parse().unwrap();
    let age = age + 1; // next birthday
    println!("next year you will be {}", age);
}

Szybkie sprawdzenie

Określ, co odróżnia przesłanianie od użycia mut.

Podsumowanie

Przesłanianie w Rust:

Powtórz let z tą samą nazwą, aby utworzyć nowe wiązanie.
Nowe wiązanie może mieć inny typ.
Każda przesłonięta wartość pozostaje niezmienna.
Różni się to od mut, które modyfikuje tę samą zmienną i zachowuje jej typ.

fn main() {
    let data = "100";
    let data: i32 = data.parse().unwrap();
    let data = data / 4;
    println!("final {}", data);
}

Często zadawane pytania

Czy lekcja „Przesłanianie” jest bezpłatna?

Tak — pełny tekst „Przesłanianie” 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 „Przesłanianie”?

Ponowne wiązanie zmiennych Ć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 „Przesłanianie”?

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