Learn Rust Coding · Lekcja

Tworzenie i wypełnianie wektorów

Zbuduje Pan/Pani Vecs i doda elementy za pomocą push.

Tworzenie i wypełnianie wektorów to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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 jest wektor?

Wektor to rozszerzalna lista wartości tego samego typu. W przeciwieństwie do tablicy o stałym rozmiarze wektor może zmniejszać się lub zwiększać podczas działania programu.

W Rust typ zapisuje się jako Vec<T>, gdzie T oznacza typ przechowywanych elementów, na przykład Vec<i32> dla liczb całkowitych.

Pusty wektor

Nowy, pusty wektor można utworzyć za pomocą Vec::new(). Ponieważ nie ma jeszcze żadnych wartości, Rust nie może odgadnąć typu elementów, dlatego zwykle trzeba go określić.

Tutaj informujemy Rust, że wektor będzie przechowywał liczby całkowite typu i32.

fn main() {
    let v: Vec<i32> = Vec::new();
    println!("len = {}", v.len());
}

Makro vec!

Najszybszym sposobem utworzenia wektora z początkowymi wartościami jest makro vec!. Wartości należy wypisać w nawiasach kwadratowych.

Rust odczytuje typ elementów z podanych wartości, więc tutaj nie trzeba go określać.

fn main() {
    let nums = vec![10, 20, 30];
    println!("{:?}", nums);
}

Wyświetlanie wektora

Cały wektor wyświetla się za pomocą formatera debugowania {:?}, a nie zwykłego {}. Forma debugowania pokazuje wartości w nawiasach kwadratowych.

Użyj {:#?}, aby uzyskać czytelny, wielowierszowy układ w przypadku dużego wektora.

fn main() {
    let names = vec!["Ann", "Bo", "Cy"];
    println!("{:?}", names);
}

Dodawanie wartości

Aby dodać wartość na końcu wektora, wywołaj push. Wektor musi być zadeklarowany jako mut, ponieważ dodawanie go zmienia.

Każde wywołanie push dołącza jeden element i zwiększa długość o jeden.

fn main() {
    let mut v = Vec::new();
    v.push(1);
    v.push(2);
    v.push(3);
    println!("{:?}", v);
}

Typ ustalany na podstawie pierwszego push

Gdy zaczynasz od Vec::new() bez określenia typu, Rust czeka na pierwsze push, aby poznać typ elementów.

Poniżej dodanie wartości 3.5 informuje Rust, że jest to Vec<f64>. Wszystkie późniejsze wartości muszą mieć ten sam typ.

fn main() {
    let mut prices = Vec::new();
    prices.push(3.5);
    prices.push(9.0);
    println!("{:?}", prices);
}

Wypełnianie powtórzeniami

Makro vec! może powtarzać wartość. Zapisz vec![value; count], aby utworzyć wektor zawierający tę wartość powtórzoną count razy.

Jest to przydatne podczas tworzenia list zer lub wartości domyślnych.

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

Wypełnianie w pętli

Wektor można wypełniać, dodając elementy wewnątrz pętli. Tutaj dodajemy kwadraty liczb od 1 do 4.

Rozpoczęcie od pustego wektora i dodawanie elementów w trakcie działania to częsty wzorzec, gdy wartości są obliczane.

fn main() {
    let mut squares = Vec::new();
    for n in 1..=4 {
        squares.push(n * n);
    }
    println!("{:?}", squares);
}

Pojemność a długość

Długość oznacza liczbę elementów przechowywanych obecnie przez wektor. Pojemność oznacza ilość zarezerwowanego miejsca, zanim wektor będzie musiał zwiększyć przydzieloną pamięć.

Jeśli mniej więcej wiesz, ile elementów dodasz, Vec::with_capacity(n) zarezerwuje miejsce z wyprzedzeniem i uniknie wielokrotnego przydzielania pamięci.

fn main() {
    let mut v = Vec::with_capacity(10);
    v.push(1);
    println!("len {}, cap {}", v.len(), v.capacity());
}

Z tablicy

Tablicę można przekształcić w wektor. Jednym z prostych sposobów jest .to_vec(), które kopiuje elementy tablicy do nowego wektora będącego własnością programu.

Jest to przydatne, gdy zaczynasz od stałych danych, ale później potrzebujesz możliwości ich rozszerzania.

fn main() {
    let arr = [1, 2, 3];
    let v = arr.to_vec();
    println!("{:?}", v);
}

Sprawdzanie, czy wektor jest pusty

Użyj is_empty(), aby sprawdzić, czy wektor nie zawiera elementów. Metoda zwraca wartość bool, co jest czytelniejsze niż porównywanie długości z zerem.

To dobre zabezpieczenie przed odczytaniem pierwszego elementu.

fn main() {
    let v: Vec<i32> = Vec::new();
    if v.is_empty() {
        println!("nothing here yet");
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat tworzenia i wypełniania wektorów.

Podsumowanie

Dowiedziałeś się, jak tworzyć wektory za pomocą Vec::new() i makra vec!, a także wypełniać je za pomocą push, powtórzeń, pętli i to_vec().

Poznałeś również różnicę między długością a pojemnością oraz sposób sprawdzania, czy wektor jest pusty. Następnie dowiesz się, jak odczytywać wartości wektora i wykonywać po nich iterację.

Często zadawane pytania

Czy lekcja „Tworzenie i wypełnianie wektorów” jest bezpłatna?

Tak — pełny tekst „Tworzenie i wypełnianie wektorów” 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 „Tworzenie i wypełnianie wektorów”?

Zbuduje Pan/Pani Vecs i doda elementy za pomocą push. Ć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 4.

Ile czasu zajmuje lekcja „Tworzenie i wypełnianie wektorów”?

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