Learn Rust Coding · Lekcja

Typy złożone

Krotki i tablice

Typy złożone to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 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 złożone?

Typy złożone grupują wiele wartości w jedną całość. Rust ma dwa pierwotne typy złożone:

Krotki — grupy o stałym rozmiarze, mogące zawierać wartości różnych typów.
Tablice — grupy o stałym rozmiarze, zawierające wartości tego samego typu.

fn main() {
    let tup = (1, 2.0, 'c');
    let arr = [10, 20, 30];
    println!("{} {}", tup.0, arr[0]);
}

Tworzenie krotek

Krotka grupuje wartości w nawiasach okrągłych. Każdy element może mieć inny typ.

Typ krotki jest kombinacją typów jej elementów.

fn main() {
    let person: (&str, u32, f64) = ("Alice", 30, 5.6);
    println!("{} is {} years old", person.0, person.1);
}

Dostęp do elementów krotki

Do elementów krotki odwołuj się za pomocą indeksu poprzedzonego kropką, zaczynając od 0.

tup.0 to pierwszy element.
tup.1 to drugi element.

fn main() {
    let point = (3, 7);
    let x = point.0;
    let y = point.1;
    println!("x={} y={}", x, y);
}

Destrukturyzacja krotek

Krotkę można rozbić na osobne zmienne w jednym kroku. Nazywa się to destrukturyzacją.

fn main() {
    let coords = (1.5, 2.5, 3.5);
    let (a, b, c) = coords;
    println!("{} {} {}", a, b, c);
}

Typ unit

Pusta krotka () nazywa się typem unit. Reprezentuje „brak znaczącej wartości”.

Funkcje, które nic nie zwracają, w rzeczywistości zwracają ().

fn main() {
    let nothing = ();
    println!("unit value is {:?}", nothing);
}

Tworzenie tablic

Tablica przechowuje wiele wartości tego samego typu i ma stałą długość; zapisuje się ją w nawiasach kwadratowych.

Jej typ ma postać [type; length].

fn main() {
    let days: [&str; 3] = ["Mon", "Tue", "Wed"];
    let numbers = [1, 2, 3, 4, 5];
    println!("{} {}", days[1], numbers[4]);
}

Indeksowanie tablic

Do elementów tablicy odwołuj się za pomocą nawiasów kwadratowych i indeksu numerowanego od zera.

Odwołanie do indeksu poza zakresem powoduje w czasie wykonywania panic — Rust sprawdza zakresy dla zapewnienia bezpieczeństwa.

fn main() {
    let colors = ["red", "green", "blue"];
    println!("first {}", colors[0]);
    println!("last {}", colors[2]);
}

Powtarzanie wartości początkowej

Aby wypełnić tablicę tą samą wartością, użyj [value; count].

Tworzy to tablicę count elementów, z których każdy jest równy value.

fn main() {
    let zeros = [0; 5];
    println!("{:?}", zeros);
    println!("length is {}", zeros.len());
}

Długość tablicy

Metoda .len() zwraca liczbę elementów tablicy. Długość jest ustalana w czasie kompilacji.

Jeśli potrzebujesz listy, którą można powiększać, użyj zamiast tego Vec.

fn main() {
    let scores = [88, 92, 75, 100];
    println!("there are {} scores", scores.len());
}

Iterowanie po tablicy

Użyj pętli for, aby odwiedzić kolejno każdy element tablicy.

fn main() {
    let nums = [2, 4, 6, 8];
    let mut sum = 0;
    for n in nums {
        sum += n;
    }
    println!("sum = {}", sum);
}

Krotki a tablice

Kiedy używać poszczególnych typów:

Użyj krotki do stałej grupy różnych typów, na przykład współrzędnej i etykiety.
Użyj tablicy do stałej grupy wartości tego samego typu, na przykład listy wyników.

fn main() {
    let record = ("Bob", [90, 85, 95]);
    println!("{} first score {}", record.0, (record.1)[0]);
}

Szybkie sprawdzenie

Wybierz prawidłowe stwierdzenie dotyczące typów złożonych w Rust.

Podsumowanie

Typy złożone w Rust:

Krotki — (a, b, c), mieszane typy, dostęp za pomocą .0, możliwość destrukturyzacji.
Tablice — [a, b, c], ten sam typ, stała długość, dostęp za pomocą [index].
() to typ unit.

fn main() {
    let (name, scores) = ("Cara", [70, 80, 90]);
    let mut total = 0;
    for s in scores {
        total += s;
    }
    println!("{} total {}", name, total);
}

Często zadawane pytania

Czy lekcja „Typy złożone” jest bezpłatna?

Tak — pełny tekst „Typy złożone” 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 złożone”?

Krotki i tablice Ć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 3 z 4.

Ile czasu zajmuje lekcja „Typy złożone”?

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