Learn Rust Coding · Lekcja

Typy skalarne

Liczby całkowite, zmiennoprzecinkowe, bool i char

Typy skalarne 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.

Czym są typy skalarne?

Typ skalarny reprezentuje pojedynczą wartość. Rust ma cztery podstawowe typy skalarne:

Liczby całkowite
Liczby zmiennoprzecinkowe
Wartości logiczne
Znaki

fn main() {
    let i = 10;       // integer
    let f = 2.5;      // float
    let b = true;     // bool
    let c = 'R';      // char
    println!("{} {} {} {}", i, f, b, c);
}

Typy całkowite

Liczby całkowite występują w wariantach ze znakiem (i) i bez znaku (u) o stałych rozmiarach: i8, i16, i32, i64, i128 oraz odpowiadające im typy u.

Domyślnym typem całkowitym jest i32.

fn main() {
    let small: i8 = -120;
    let big: u64 = 18_000_000_000;
    println!("{} {}", small, big);
}

Ze znakiem a bez znaku

Liczby całkowite ze znakiem mogą być ujemne, natomiast liczby bez znaku — nie.

i8 obejmuje zakres od -128 do 127.
u8 obejmuje zakres od 0 do 255.

Typu bez znaku należy używać, gdy wartość nigdy nie może być ujemna, na przykład w przypadku licznika.

fn main() {
    let temperature: i32 = -15;
    let people: u32 = 250;
    println!("temp {} people {}", temperature, people);
}

Literały całkowite

Liczby całkowite można zapisywać w różnych systemach liczbowych, a dla zwiększenia czytelności można używać podkreśleń.

Dziesiętny: 1_000_000
Szesnastkowy: 0xff
Ósemkowy: 0o77
Binarny: 0b1010

fn main() {
    let dec = 1_000;
    let hex = 0xff;
    let bin = 0b1010;
    println!("{} {} {}", dec, hex, bin);
}

Typy zmiennoprzecinkowe

Rust ma dwa typy zmiennoprzecinkowe: f32 i f64. Domyślnie używany jest f64, ponieważ zapewnia większą precyzję.

Liczby zmiennoprzecinkowe są zgodne ze standardem IEEE-754.

fn main() {
    let pi: f64 = 3.141592;
    let e: f32 = 2.718;
    println!("pi {} e {}", pi, e);
}

Operacje numeryczne

Rust obsługuje typowe operatory matematyczne: +, -, *, / i % (reszta z dzielenia).

Dzielenie liczb całkowitych obcina wynik w kierunku zera.

fn main() {
    let sum = 5 + 10;
    let quotient = 7 / 2;     // 3 (integer)
    let remainder = 7 % 2;    // 1
    let float_div = 7.0 / 2.0; // 3.5
    println!("{} {} {} {}", sum, quotient, remainder, float_div);
}

Typ Boolean

Typ bool ma dokładnie dwie wartości: true i false.

Wartości logiczne są wynikiem porównań i są używane w warunkach if.

fn main() {
    let is_active = true;
    let is_bigger = 10 > 3;
    println!("{} {}", is_active, is_bigger);
}

Typ znakowy

Typ char reprezentuje pojedynczą skalarną wartość Unicode i zapisuje się go za pomocą pojedynczych cudzysłowów.

Rustowy char zajmuje 4 bajty i może przechowywać znacznie więcej niż znaki ASCII — także emoji i litery diakrytyzowane.

fn main() {
    let letter = 'A';
    let symbol = '@';
    let heart = '\u{2764}';
    println!("{} {} {}", letter, symbol, heart);
}

char a String

Pojedyncze cudzysłowy tworzą wartość typu char, a podwójne cudzysłowy tworzą wycinek łańcucha znaków (&str).

'a' to pojedynczy znak.
"a" to jednoznakowy łańcuch.

fn main() {
    let c = 'x';
    let s = "x";
    println!("char {} string {}", c, s);
}

Konwersja typów za pomocą as

Rust nie konwertuje automatycznie typów liczbowych. Do jawnych rzutowań należy używać słowa kluczowego as.

Należy zachować ostrożność: rzutowanie na typ o mniejszym zakresie może spowodować utratę danych.

fn main() {
    let x: i32 = 65;
    let y: f64 = x as f64;
    let c = x as u8 as char;
    println!("{} {} {}", x, y, c);
}

Łączenie typów skalarnych

Programy nieustannie łączą typy skalarne. W tym przykładzie mieszamy liczby całkowite, zmiennoprzecinkowe i wartości logiczne, aby podjąć decyzję.

fn main() {
    let price: f64 = 19.99;
    let quantity: u32 = 3;
    let total = price * quantity as f64;
    let is_expensive = total > 50.0;
    println!("total {} expensive {}", total, is_expensive);
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat literałów skalarnych w Rust.

Podsumowanie

Cztery typy skalarne w Rust:

Liczby całkowite — ze znakiem (i32) i bez znaku (u32), w różnych rozmiarach.
Liczby zmiennoprzecinkowe — f32 i f64, domyślnie f64.
bool — true lub false.
char — pojedyncza wartość Unicode zapisywana w pojedynczych cudzysłowach.

Do jawnych konwersji liczbowych używaj as.

fn main() {
    let count: u32 = 42;
    let ratio: f64 = count as f64 / 7.0;
    let ok: bool = ratio > 5.0;
    let grade: char = 'B';
    println!("{} {} {} {}", count, ratio, ok, grade);
}

Często zadawane pytania

Czy lekcja „Typy skalarne” jest bezpłatna?

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

Liczby całkowite, zmiennoprzecinkowe, bool i char Ć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 „Typy skalarne”?

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