0Pricing
Learn Rust Coding · Lekcja

Pierwotne typy danych i operatory

Poznają Państwo wbudowane pierwotne typy danych języka Rust, takie jak liczby całkowite, liczby zmiennoprzecinkowe, wartości logiczne i znaki, a także popularne operatory.

Pierwotne typy danych i operatory to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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 podstawowych typów danych

Witaj w podstawowej lekcji Rust! Dziś omówimy podstawowe typy danych i podstawowe operatory.

Typy podstawowe to najważniejsze elementy służące do przechowywania danych. Reprezentują proste wartości, takie jak liczby, wartości prawda/fałsz lub pojedyncze znaki.

Zrozumienie tych typów ma kluczowe znaczenie dla pisania wydajnego i poprawnego kodu Rust.

Typy całkowitoliczbowe w Rust

Rust udostępnia różne typy całkowitoliczbowe, dostosowane do różnych potrzeb. Dzielą się one na dwie główne grupy:

  • Liczby całkowite ze znakiem (prefiks i): mogą przechowywać zarówno liczby dodatnie, jak i ujemne (np. i8, i32, i64).
  • Liczby całkowite bez znaku (prefiks u): mogą przechowywać tylko liczby dodatnie lub zero (np. u8, u32, u64).

Liczba wskazuje liczbę bitów zajmowanych w pamięci, np. i32 to 32-bitowa liczba całkowita ze znakiem. Typy isize i usize mają rozmiar wskaźnika i dostosowują się do architektury systemu (32- lub 64-bitowej).

Deklarowanie zmiennych całkowitoliczbowych

Zobaczmy, jak deklarować i używać typów całkowitoliczbowych w Rust. Zwróć uwagę, że można jawnie dodać adnotację typu albo pozwolić Rust na wywnioskowanie typu.

Uruchom ten przykład:

fn main() {
  let signed_val: i32 = -100;
  let unsigned_val: u32 = 250;
  let inferred_int = 500; // Rust infers i32 by default
  let big_unsigned: u64 = 1_000_000_000;

  println!("Signed: {}", signed_val);
  println!("Unsigned: {}", unsigned_val);
  println!("Inferred: {}", inferred_int);
  println!("Big Unsigned: {}", big_unsigned);
}

Liczby zmiennoprzecinkowe

Do liczb z częścią ułamkową Rust udostępnia typy zmiennoprzecinkowe:

  • f32: liczba zmiennoprzecinkowa pojedynczej precyzji (32-bitowa).
  • f64: liczba zmiennoprzecinkowa podwójnej precyzji (64-bitowa). Jest to domyślny typ zmiennoprzecinkowy w Rust.

f64 jest zazwyczaj preferowany w większości zastosowań ze względu na większą precyzję, chyba że występują konkretne ograniczenia pamięci lub wydajności.

Deklarowanie zmiennych zmiennoprzecinkowych

Oto jak deklarować liczby zmiennoprzecinkowe. Należy zauważyć, że jeśli nie określi się typu, Rust domyślnie używa f64.

Proszę uruchomić ten przykład:

fn main() {
  let pi: f32 = 3.14159;
  let e = 2.718281828; // Inferred as f64
  let temperature: f64 = 98.6;

  println!("Pi (f32): {}", pi);
  println!("E (f64 inferred): {}", e);
  println!("Temperature (f64): {}", temperature);
}

Wartości logiczne i znaki

Oprócz liczb Rust ma typy reprezentujące wartości logiczne i pojedyncze znaki:

  • bool: Reprezentuje wartość logiczną — true albo false.
  • char: Reprezentuje pojedynczą wartość skalarną Unicode. Oznacza to, że char może reprezentować nie tylko znak ASCII — może to być dowolna litera, emoji lub symbol.

Typ char zajmuje 4 bajty pamięci, dzięki czemu może przechowywać dowolny znak Unicode.

Wartości bool i char w praktyce

Zadeklarujmy kilka zmiennych logicznych i znakowych. Należy zwrócić uwagę na pojedyncze cudzysłowy używane dla wartości char.

Proszę uruchomić ten przykład:

fn main() {
  let is_rust_fun: bool = true;
  let has_errors = false; // Inferred as bool
  let first_letter: char = 'R';
  let emoji_char: char = '🚀';

  println!("Is Rust fun? {}", is_rust_fun);
  println!("Has errors? {}", has_errors);
  println!("First letter: {}", first_letter);
  println!("Emoji: {}", emoji_char);
}

Podstawowe operatory arytmetyczne

Podobnie jak w matematyce, Rust używa operatorów do wykonywania obliczeń. Oto najczęściej używane operatory arytmetyczne:

  • +: Dodawanie
  • -: Odejmowanie
  • *: Mnożenie
  • /: Dzielenie
  • %: Reszta z dzielenia (modulo)

Należy pamiętać, że dzielenie całkowite (np. 10 / 3) odrzuca część dziesiętną, zwracając liczbę całkowitą (3, a nie 3.33).

Używanie operatorów arytmetycznych

Zastosujmy te operatory w praktyce, wykonując działania na liczbach. Proszę zwrócić uwagę na sposób działania dzielenia całkowitego!

Proszę uruchomić ten przykład:

fn main() {
  let a = 15;
  let b = 4;

  println!("Addition: 15 + 4 = {}", a + b);
  println!("Subtraction: 15 - 4 = {}", a - b);
  println!("Multiplication: 15 * 4 = {}", a * b);
  println!("Integer Division: 15 / 4 = {}", a / b);
  println!("Remainder: 15 % 4 = {}", a % b);

  let x = 15.0;
  let y = 4.0;
  println!("Float Division: 15.0 / 4.0 = {}", x / y);
}

Quiz: typy proste

Sprawdź swoją znajomość typów danych prostych i podstawowych operatorów w języku Rust.

Podsumowanie: typy proste i operatory

Świetnie! Poznali Państwo podstawowe typy danych w języku Rust:

  • Liczby całkowite: i8, u8, i32, u32 itd. służą do reprezentowania liczb całkowitych.
  • Liczby zmiennoprzecinkowe: f32 i f64 służą do reprezentowania liczb dziesiętnych.
  • Wartości logiczne: bool przyjmuje wartość true albo false.
  • Znaki: char reprezentuje pojedyncze wartości Unicode.

Poznali Państwo również podstawowe operatory arytmetyczne, takie jak +, -, *, / i %. Są one podstawą bardziej złożonej logiki w programach.

Często zadawane pytania

Czy lekcja „Pierwotne typy danych i operatory” jest bezpłatna?

Tak — pełny tekst „Pierwotne typy danych i operatory” 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 „Pierwotne typy danych i operatory”?

Poznają Państwo wbudowane pierwotne typy danych języka Rust, takie jak liczby całkowite, liczby zmiennoprzecinkowe, wartości logiczne i znaki, a także popularne operatory. Ć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 3.

Ile czasu zajmuje lekcja „Pierwotne typy danych i operatory”?

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

  1. Zmienne, mutowalność i shadowing
  2. Pierwotne typy danych i operatory
  3. Funkcje i sterowanie przepływem
← Powrót do Learn Rust Coding