0Pricing
Learn Rust Coding · Lekcja

Zarządzanie zależnościami za pomocą crates

Dowiedzą się Państwo, jak Cargo zarządza zewnętrznymi crates (bibliotekami) oraz jak publikować własne crate’y do użytku społeczności.

Zarządzanie zależnościami za pomocą crates 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.

Czym są crate'y i Cargo?

W Rust crate jest podstawową jednostką kompilacji i dystrybucji. Można myśleć o nim jak o pakiecie lub bibliotece zawierającej kod.

Cargo to oficjalny menedżer pakietów i system budowania dla Rust. Obsługuje wszystko — od tworzenia nowych projektów, przez zarządzanie zależnościami, kompilowanie kodu i uruchamianie testów. To najlepszy przyjaciel każdego programisty Rust!

Plik `Cargo.toml`

Każdy projekt Rust zarządzany przez Cargo ma w katalogu głównym plik Cargo.toml. Jest to plik manifestu projektu zapisany w formacie TOML (Tom's Obvious, Minimal Language).

Definiuje metadane projektu i, co najważniejsze, zawiera listę jego zależności.

Konfiguracja projektu

Sekcja [package] w pliku Cargo.toml zawiera podstawowe informacje o crate:

  • name: nazwa crate.
  • version: jego bieżąca wersja.
  • edition: używana edycja Rust (np. 2021).
  • authors: autorzy.

Te informacje są szczególnie ważne, jeśli planuje Pan opublikować crate.

Dodawanie zależności

Aby używać zewnętrznych bibliotek (innych crate) w projekcie, należy umieścić je w sekcji [dependencies] pliku Cargo.toml.

Podczas budowania projektu Cargo automatycznie pobiera i kompiluje te zależności z serwisu crates.io, centralnego rejestru pakietów Rust.

Składnia zależności

Oto jak zadeklarować zależność w pliku Cargo.toml:

[dependencies] rand = "0.8.5"

Informuje to Cargo, aby pobrało wersję 0.8.5 crate rand. Można również określić zakresy wersji lub ścieżki lokalne.

Używanie crate: przykład

Dodajmy crate rand, aby wygenerować losową liczbę. Najpierw upewnij się, że w sekcji [dependencies] znajduje się rand = "0.8.5". Następnie użyj go w kodzie:

use rand::Rng; // Import the Rng trait

fn main() {
  let mut rng = rand::thread_rng(); // Create a random number generator
  let n: u8 = rng.gen_range(1..=10); // Generate a number between 1 and 10 (inclusive)
  println!("Your random number is: {}", n);
}

Plik `Cargo.lock`

Po zbudowaniu projektu z zależnościami Cargo tworzy plik Cargo.lock. Zapisuje on dokładne wersje wszystkich bezpośrednich i pośrednich zależności używanych w projekcie.

Zapewnia to wszystkim osobom pracującym nad projektem te same wersje zależności, co prowadzi do powtarzalnych kompilacji w różnych środowiskach.

Aktualizowanie zależności

Z czasem dla zależności mogą pojawić się nowe wersje zawierające poprawki błędów lub nowe funkcje. Aby je zaktualizować, należy użyć polecenia cargo update.

To polecenie sprawdza w serwisie crates.io, czy są nowsze wersje spełniające wymagania wersji określone w pliku Cargo.toml, a następnie odpowiednio aktualizuje plik Cargo.lock.

Publikowanie własnego crate

Chce Pan podzielić się swoim świetnym kodem Rust ze społecznością? Można opublikować własny crate w serwisie crates.io!

Przed publikacją należy upewnić się, że plik Cargo.toml zawiera odpowiednie metadane, takie jak description, license i odnośniki repository.

Polecenia publikowania

Proces jest prosty:

  1. Zaloguj się: użyj polecenia cargo login <token> z tokenem API z serwisu crates.io.
  2. Opublikuj: uruchom polecenie cargo publish w katalogu głównym projektu.

Cargo przeprowadzi kontrole, spakuje kod i prześle go, dzięki czemu inni będą mogli z niego korzystać!

Szybkie sprawdzenie: Cargo i crate'y

Które z poniższych stwierdzeń dotyczących zarządzania pakietami Rust za pomocą Cargo są prawdziwe?

Powtórzenie: zarządzanie zależnościami

Opanował(a) Pan/Pani już wiedzę o tym, że Cargo jest niezbędne do zarządzania projektami Rust i ich zależnościami!

  • Crates to pakiety wielokrotnego użytku zawierające kod.
  • Cargo.toml definiuje projekt i jego zależności.
  • Cargo.lock zapewnia powtarzalność kompilacji.
  • Można publikować własne crates w crates.io.

Ten potężny system sprawia, że udostępnianie i ponowne wykorzystywanie kodu w Rust jest niezwykle wydajne i niezawodne.

Często zadawane pytania

Czy lekcja „Zarządzanie zależnościami za pomocą crates” jest bezpłatna?

Tak — pełny tekst „Zarządzanie zależnościami za pomocą crates” 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 „Zarządzanie zależnościami za pomocą crates”?

Dowiedzą się Państwo, jak Cargo zarządza zewnętrznymi crates (bibliotekami) oraz jak publikować własne crate’y do użytku społeczności. Ć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 „Zarządzanie zależnościami za pomocą crates”?

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. Organizowanie kodu za pomocą modułów
  2. Zarządzanie zależnościami za pomocą crates
  3. Solidna obsługa błędów za pomocą `Result`
← Powrót do Learn Rust Coding