Learn Rust Coding · Lekcja

Zmienne, mutowalność i shadowing

Dowiedzą się Państwo, jak deklarować zmienne, zarządzać ich mutowalnością oraz używać shadowingu do elastycznego ponownego definiowania zmiennych.

Zmienne, mutowalność i shadowing to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 3. 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 3 lekcji w sumie.

Wprowadzenie do zmiennych w Rust

Witaj! W Rust zmienne są podstawą przechowywania danych. Przypominają opisane pudełka, w których przechowuje się informacje potrzebne programowi.

Rust kładzie duży nacisk na bezpieczeństwo, a zaczyna się ono od sposobu obsługi zmiennych. Dowiesz się, jak je deklarować, kontrolować ich modyfikowalność, a nawet sprytnie je „przesłaniać”.

Deklarowanie zmiennych za pomocą `let`

Aby utworzyć zmienną w Rust, używamy słowa kluczowego let. Przypisuje ono nazwę wartości. Rust często sam wnioskuje typ, więc nie zawsze trzeba go określać.

Uruchom ten prosty przykład:

fn main() {
  let apples = 5;
  println!("I have {} apples.", apples);
}

Domyślna niezmienność w Rust

Jedną z najważniejszych cech Rust jest to, że zmienne są domyślnie niezmienne. Po przypisaniu wartości do zmiennej nie można jej później zmienić.

Może się to wydawać ograniczeniem, ale pomaga zapobiegać błędom oraz sprawia, że kod jest bezpieczniejszy i łatwiejszy do przeanalizowania, zwłaszcza w programowaniu współbieżnym.

Uczynienie zmiennych modyfikowalnymi za pomocą `mut`

Jeśli wartość zmiennej musi się zmieniać, można jawnie uczynić ją modyfikowalną, używając słowa kluczowego mut przed nazwą zmiennej.

Informuje to Rust (i innych programistów), że wartość tej zmiennej ma być zmieniana.

fn main() {
  let mut score = 100;
  println!("Initial score: {}", score);

  score = 150; // We can change it now!
  println!("New score: {}", score);
}

Kiedy używać `mut`

Choć mut jest przydatne, dobrą praktyką jest używanie go tylko wtedy, gdy jest to konieczne. Warto domyślnie preferować niezmienność.

Używaj mut dla liczników, zmiennych przechowujących stan lub wartości, które rzeczywiście muszą być aktualizowane.
Jeśli wartość nie zmienia się po początkowym przypisaniu, pozostaw ją niezmienną (bez mut).
Przejrzystość: jawne oznaczenie zmiennej jako mut wyraźniej pokazuje intencję kodu.

Definiowanie stałych za pomocą `const`

Stałe to szczególny rodzaj niezmiennych zmiennych. Deklaruje się je za pomocą słowa kluczowego const zamiast let, a ich typ zawsze musi być określony jawnie.

Stałym można przypisywać tylko wyrażenia stałe, a nie wynik wywołania funkcji ani wartość, którą można obliczyć dopiero podczas działania programu.

fn main() {
  const MAX_USERS: u32 = 10_000; // Type annotation is required!
  println!("Max users allowed: {}", MAX_USERS);
}

Zmienne `let` a stałe `const`

Oto najważniejsze różnice między zmiennymi let a stałymi const:

Modyfikowalność: zmienne let są domyślnie niezmienne, ale można uczynić je modyfikowalnymi za pomocą mut. Stałe const są zawsze niezmienne.
Deklaracja: let używa słowa let. const używa słowa const.
Adnotacja typu: w przypadku zmiennych let typ często może zostać wywnioskowany. Stałe const muszą mieć jawnie określony typ.
Zakres: stałe const można deklarować w dowolnym zakresie, w tym w zakresie globalnym.

Wprowadzenie do przesłaniania

Rust pozwala zadeklarować nową zmienną o tej samej nazwie co wcześniejsza zmienna. Nazywa się to przesłanianiem.

Nowa zmienna „przesłania” starą, więc cały późniejszy kod będzie odwoływać się do wartości nowej zmiennej. Stara zmienna nadal istnieje w pamięci, ale nie można już uzyskać do niej bezpośredniego dostępu.

fn main() {
  let x = 5;
  println!("First x: {}", x); // Outputs 5

  let x = x + 1; // 'x' is shadowed by a new 'x'
  println!("Second x: {}", x); // Outputs 6

  { // Inner scope
    let x = x * 2; // 'x' is shadowed again
    println!("Inner x: {}", x); // Outputs 12
  }
  println!("Outer x: {}", x); // Outputs 6 (inner x is out of scope)
}

Przesłanianie przy konwersji typu

Jednym z praktycznych zastosowań przesłaniania jest przekształcenie wartości zmiennej, a nawet jej typu, przy zachowaniu tej samej nazwy. Jest to częste, gdy trzeba sparsować ciąg znaków do liczby.

Zamiast tworzyć nową nazwę zmiennej (np. string_val, a następnie num_val), można ponownie użyć tej samej nazwy.

fn main() {
  let spaces = "   ";
  println!("Spaces string: '{}'", spaces);

  // Shadow 'spaces' with a new variable that holds its length
  let spaces = spaces.len();
  println!("Spaces count: {}", spaces);
}

Szybkie sprawdzenie: zmienne i modyfikowalność

Rozważ poniższy kod Rust. Jaka będzie końcowa wartość zmiennej y wyświetlona w konsoli?

Podsumowanie zmiennych, modyfikowalności i przesłaniania

Świetna praca! Poznał(a) Pan/Pani najważniejsze informacje o zmiennych w Rust:

Używaj let do deklarowania zmiennych, które są domyślnie niezmienne.
Dodaj mut, aby uczynić zmienną modyfikowalną i umożliwić zmianę jej wartości.
Używaj const dla stałych, które są zawsze niezmienne i wymagają adnotacji typu.
Przesłanianie pozwala zadeklarować nową zmienną o tej samej nazwie, zastępując poprzednią. Jest to przydatne przy konwersji typów.

Następnie omówimy różne podstawowe typy danych w Rust!

Często zadawane pytania

Czy lekcja „Zmienne, mutowalność i shadowing” jest bezpłatna?

Tak — pełny tekst „Zmienne, mutowalność i shadowing” 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 3 lekcji w sumie.

Co nauczysz się w „Zmienne, mutowalność i shadowing”?

Dowiedzą się Państwo, jak deklarować zmienne, zarządzać ich mutowalnością oraz używać shadowingu do elastycznego ponownego definiowania 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 1 z 3.

Ile czasu zajmuje lekcja „Zmienne, mutowalność i shadowing”?

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