Learn Rust Coding · Lekcja

UTF-8 i znaki

Obsługa Unicode

UTF-8 i znaki 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.

Napisy w Rust używają UTF-8

Każda wartość String i &str w Rust jest zakodowana w standardzie UTF-8. Oznacza to, że tekst może zawierać dowolne znaki Unicode, nie tylko ASCII.

fn main() {
    let s = String::from("caf\u{e9}");
    println!("{}", s);
}

Czym jest UTF-8?

UTF-8 koduje każdy znak Unicode za pomocą od jednego do czterech bajtów. Znaki ASCII zajmują jeden bajt, a litery diakrytyczne i emoji — więcej.

fn main() {
    let ascii = "A";          // 1 byte
    let accent = "\u{e9}";    // 2 bytes (e-acute)
    println!("{} bytes vs {} bytes", ascii.len(), accent.len());
}

Bajty a znaki

Ze względu na kodowanie wielobajtowe len() zwraca liczbę bajtów, która może być większa niż liczba znaków.

fn main() {
    let s = "caf\u{e9}";
    println!("bytes {}", s.len());
    println!("chars {}", s.chars().count());
}

Typ char reprezentuje Unicode

Wartość Rust typu char zajmuje 4 bajty i może przechowywać dowolną wartość skalarną Unicode, a nie tylko pojedynczy bajt.

fn main() {
    let letter = 'Z';
    let accented = '\u{f1}'; // n with tilde
    println!("{} {}", letter, accented);
}

Iterowanie po znakach

Użyj chars(), aby przechodzić po tekście znak po znaku. Metoda ta poprawnie obsługuje znaki wielobajtowe.

fn main() {
    let s = "a\u{e9}z";
    for c in s.chars() {
        println!("{}", c);
    }
}

Dlaczego nie można indeksować numerem

Rust nie pozwala używać s[0] na napisie. Ponieważ znaki mogą zajmować różną liczbę bajtów, indeksowanie pojedynczym numerem byłoby niejednoznaczne i niebezpieczne.

fn main() {
    let s = "hello";
    // let c = s[0]; // error: cannot index a str
    let first = s.chars().next().unwrap();
    println!("{}", first);
}

Pobieranie n-tego znaku

Użyj metody iteratora nth, aby pobrać znak o określonej pozycji. Zwraca ona wartość Option.

fn main() {
    let s = "abcdef";
    let third = s.chars().nth(2);
    println!("{:?}", third);
}

Iterowanie po bajtach

Jeśli rzeczywiście potrzebujesz surowych bajtów, użyj bytes(), które zwraca wartości u8.

fn main() {
    let s = "AB";
    for b in s.bytes() {
        println!("{}", b);
    }
}

Wycinanie na granicach bajtów

Wycinki napisów używają indeksów bajtowych. Wycinanie musi kończyć się na prawidłowej granicy znaku, w przeciwnym razie program wywoła panic.

fn main() {
    let s = "hello";
    let part = &s[0..3]; // valid ASCII boundary
    println!("{}", part);
}

Metody typu char

Typ char ma przydatne metody, takie jak is_alphabetic, is_numeric i to_uppercase.

fn main() {
    let c = 'k';
    println!("alpha {} numeric {}", c.is_alphabetic(), c.is_numeric());
    println!("upper {}", c.to_uppercase());
}

Zliczanie określonych znaków

Połącz chars z filter, aby zliczyć znaki spełniające określony warunek.

fn main() {
    let s = "banana";
    let a_count = s.chars().filter(|&c| c == 'a').count();
    println!("a appears {} times", a_count);
}

Szybkie sprawdzenie

Przypomnij sobie, dlaczego długość napisu może być zaskakująca.

Podsumowanie

UTF-8 i char w Rust:

Napisy są kodowane w UTF-8; znaki zajmują od 1 do 4 bajtów.
len() zwraca liczbę bajtów, a chars().count() — liczbę znaków.
Nie można indeksować napisu numerem; należy użyć chars() lub nth.
Wycinki muszą zaczynać się i kończyć na granicach znaków.

fn main() {
    let s = "sm\u{ee}le";
    println!("bytes {} chars {}", s.len(), s.chars().count());
    for c in s.chars() {
        print!("{} ", c);
    }
    println!();
}

Często zadawane pytania

Czy lekcja „UTF-8 i znaki” jest bezpłatna?

Tak — pełny tekst „UTF-8 i znaki” 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 „UTF-8 i znaki”?

Obsługa Unicode Ć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 „UTF-8 i znaki”?

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