Kompletne wprowadzenie do Rust: praktyczny przewodnik dla początkujących z przykładami

Odkrywanie Rusta może być nie lada przygodą dla tych, którzy szukają języka łączącego w sobie wydajność, bezpieczeństwo i nienaganne zarządzanie pamięcią., nie rezygnując z łatwości użytkowania. W tym artykule zanurzymy się w fascynujący świat Rust, rozpakowując jego fundamenty, główne mocne i słabe strony oraz pokazując praktyczne przykłady, abyś mógł w pełni wykorzystać jego możliwości od pierwszego dnia.

Choć na pierwszy rzut oka może przypominać inne języki systemowe, takie jak C czy C++, Rust zyskuje coraz większą popularność dzięki nowoczesnemu podejściu do języka. obecność i bezpieczeństwoJest to rozwiązanie idealne zarówno dla początkujących, jak i doświadczonych programistów, którzy chcą uniknąć problemów z błędami pamięci lub wyścigami warunków.

Czym jest Rust i dlaczego zyskuje tak dużą popularność?

Rdza to język programowanie systemów którego głównym celem jest zapewnienie równowagi pomiędzy bezpieczeństwo, szybkość i frekwencja. Powstał z myślą o wyeliminowaniu typowych błędów występujących w innych podobnych językach, jak te irytujące Wskaźniki zerowe, wycieki pamięci i wyścigi warunków które często występują w środowiskach współbieżnych.

Wielu uważa go za naturalnego następcę języków C i C++, ale z nowoczesną składnią, dynamicznym ekosystemem i radykalnym skupieniem na niezawodność oprogramowanieKorzystają z niego takie firmy jak Mozilla, Dropbox, Cloudflare, Canonical i wiele innych w projektach systemów i aplikacji o wysokiej wydajności.

To są główne Różnicowe wartości rdzy:

• Zarządzanie pamięcią bez zbierania śmieci: Dzięki systemowi własności i ścisłym regułom pożyczania, wiele typowych problemów z pamięcią zostało rozwiązanych bez konieczności korzystania z inwazyjnego programu do usuwania śmieci.
• Bezpieczna i wydajna współbieżność: Kompilator dba o to, aby nie występowały sytuacje wyścigu, co ułatwia wykonywanie wielu zadań jednocześnie.
• Prędkość porównywalna z C/C++: Po skompilowaniu i kontrolowaniu za pomocą alokacji pamięci uzyskuje się szybkie i wydajne pliki binarne.
• Solidny i statyczny system typów: Wykrywa wiele błędów w czasie kompilacji, ułatwiając konserwację i rozwój projektów.

Rust jest oprogramowaniem typu open source i ma bardzo aktywną społeczność, która dysponuje licznymi zasobami, takimi jak samouczki, książki, fora i wykłady dla osób na wszystkich poziomach zaawansowania.

Instalowanie i konfigurowanie środowiska programistycznego

Rozpoczęcie pracy z Rustem jest bardzo proste. Zalecana metoda instalacji języka i jego podstawowych narzędzi to zardzewiały. Ten instalator umożliwia pobranie najnowszej stabilnej wersji Rust wraz z rdzawy (kompilator) i Ładunek (menedżer pakietów i kompilacja projektu).

W systemach GNU/Linux lub MacOS, po prostu uruchom następujące polecenie w terminal:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | cii

En Windows Plik wykonywalny rustup-init.exe możesz pobrać z oficjalnej strony internetowej i postępować zgodnie z instrukcjami kreatora instalacji.

Aby sprawdzić, czy instalacja zakończyła się powodzeniem, uruchom:

rustc --wersja

Pokaże zainstalowaną wersję kompilatora Rust. Jeśli wystąpią jakiekolwiek problemy, zwłaszcza na macOS, możesz upewnić się, że masz zainstalowane narzędzia programistyczne Xcode za pomocą:

xcode-select --instalacja

Są też rozszerzenia dla IDE najpopularniejsze, takie jak VS Code, IntelliJ IDEA, Emacs i Nano, dzięki czemu można łatwo edytować, automatycznie uzupełniać i debugować kod Rust.

Kluczowe narzędzia: rustup, rustc i Cargo

Gdy środowisko jest już gotowe, warto poznać najważniejsze narzędzia domyślnie zawarte w Rust:

• rdza: Zarządza różnymi wersjami Rust i kanałami aktualizacji (stabilna, beta, nocna). Umożliwia łatwą instalację, aktualizację lub przełączanie się między wersjami.
• rustykalny: jest kompilatorem Rust. Przekształca kod źródłowy (.rs) w pliki wykonywalne binarne. Można go wywołać bezpośrednio lub przez Cargo.
• Stanowisko: To serce ekosystemu Rust, zarządzanie kompilacjami projektów, zależnościami (skrzyniami), testami, dokumentacją i nie tylko. Stanie się Twoim najlepszym przyjacielem od pierwszego dnia.

Aby utworzyć nowy projekt, typowe polecenie wygląda następująco:

ładunek nowy my_project

Generuje standardową strukturę katalogów i plików, łącznie z manifestem. Ładunek.toml i główny plik źródłowy źródło/main.rs. Wystarczy, że edytujesz ten ostatni kodem.

Aby skompilować i uruchomić projekt, użyj:

cargo build # Zbuduj projekt (plik binarny w target/debug/) cargo run # Zbuduj i uruchom wynikowy plik binarny

Podstawy składniowe i struktura programu Rust

La podstawowa struktura programu w Rust To proste i będzie znajome tym, którzy pracowali z innymi językami kompilowanymi. Zobaczmy, jak wyglądałby klasyczny „Hello World”:

fn main() { println!("Witaj, świecie!"); }

Główna funkcja funkcja główna() jest punktem wejścia. Symbol ! trans drukuj wskazuje, że jest to makro (specjalna cecha języka Rust dla wygenerować kod). Średnik ; dokończ instrukcję.

Kod źródłowy zwykle znajduje się w plikach z rozszerzeniem .rs a składnia przypomina składnię innych języków systemowych.

Zmienne, stałe i zmienność

W Rust wszystkie zmienne są domyślnie niezmiennyOznacza to, że po przypisaniu wartości nie można jej zmienić, chyba że wyraźnie podano inaczej. Zapobiega to wielu błędom i sprawia, że ​​kod jest bardziej przewidywalny.

Aby zadeklarować zmienną, należy użyć niech:

niech x = 10; // x = 20; // To się nie powiedzie, ponieważ x jest niezmienne

Jeżeli chcesz, aby zmienna mogła zostać zmieniona, wskaż ją za pomocą mut:

niech mut x = 10; x = 20; // Teraz jest to legalne

Te stałe są zdefiniowane za pomocą const i musi mieć jawny typ, przy czym zgodnie z konwencją nazwa musi być pisana wielkimi literami:

stała MAX_SIZE: i32 = 100;

Dzięki temu kod staje się bardziej wytrzymały i łatwiejszy w utrzymaniu.

Typy danych: skalarne i złożone

Rdza ma szeroka gama typów pierwotnych, zarówno skalarne, jak i złożone. Przyjrzyjmy się najważniejszym:

• Liczby całkowite ze znakiem: i8, i16, i32, i64, i128, rozmiar
• Liczby całkowite bez znaku: u8, u16, u32, u64, u128, użyj
• Zmiennoprzecinkowy: f32, f64 (wartość domyślna dla liczb dziesiętnych to f64)
• Postacie: char (obsługuje pełny Unicode)
• Wartości logiczne: bool (prawda lub fałsz)
• Typ jednostki: () (podobne do void w innych językach)

Do kolekcji mamy dostępne krotki y tablice:

• Krotki: Umożliwiają grupowanie wartości różnych typów i dostęp do nich według pozycji:

niech krotka = (1, "tekst", prawda); niech pierwszy = krotka.0; // 1

• Tablice: Przechowują kilka wartości tego samego typu zgrupowanych razem. Rozmiar musi być określony:

niech tablica: [i32; 3] = [10, 20, 30];

Tablice mają stały rozmiar i zajmują ciągłą pamięć, co poprawia wydajność.

Zarządzanie pamięcią: stos i sterta

Rdza wyraźnie rozróżnia pamięć stosowa i stertowaDomyślnie dane o znanym, stałym rozmiarze są przechowywane na stosie, natomiast dane wymagające dynamicznego rozmiaru (np. wektory) są przechowywane na stercie.

Dużą różnicą w porównaniu do innych języków, takich jak C, jest to, że Rust stosuje system własności (właściwość), eliminując potrzebę ręcznego zarządzania pamięcią, ale bez użycia zbieracza śmieci.

Przykład podstawowego stosu i sterty:

niech x = 5; // x jest przechowywane na stosie niech v = vec![1, 2, 3]; // v (odniesienie i metadane) na stosie, dane na stercie

System własności, pożyczania i okresów użytkowania

Sercem zarządzania pamięcią w Rust jest jej system własnościKażda wartość ma jednego właściciela; gdy wychodzi poza zakres, pamięć jest automatycznie zwalniana. Przyjrzyjmy się przykładowi:

let s1 = String::from("hello"); let s2 = s1; // println!("{}", s1); // Błąd: s1 nie jest już prawidłowy, własność została przeniesiona na s2

Jeśli chcemy, aby obie zmienne były prawidłowe, musimy utworzyć głęboka kopia:

let s1 = String::from("hello"); let s2 = s1.clone(); // Teraz oba są niezależne

Gdy funkcja przyjmuje wartość jako parametr, domyślnie przejmuje jej własność:

fn take_ownership(s: String) { println!("{}", s); } let my_string = String::from("owner"); take_ownership(my_string); // println!("{}", my_string); // Błąd, własność została przeniesiona

Aby tego uniknąć, stosuje się je referencje (&), umożliwiając tymczasowy dostęp do wartości:

fn read_reference(s: &String) { println!("{}", s); }

Jeżeli chcemy zmodyfikować wartość, musimy użyć zmiennych odniesień (&mut) i przestrzegać zasady, że w danym momencie może istnieć tylko jedno odniesienie zmienne lub wiele odniesień niezmiennych.

Makra i funkcje w Rust

Rust pozwala na jasne i łatwe definiowanie funkcji. Słowo kluczowe fn zaczyna się definicja. Jeśli funkcja zwraca wartość, po prostu umieść wyrażenie (bez średnika) na końcu:

fn sum(a: i32, b: i32) -> i32 { a + b }

Cechą szczególną języka Rust jest makra, zidentyfikowany z !, Na przykład drukuj! do drukowania na konsoli. Umożliwiają generowanie kodu w czasie kompilacji i są szczególnie przydatne do automatyzacji powtarzających się zadań.

Struktury (structs) i wyliczenia (enums)

Te struktury w Rust pozwalają na tworzenie niestandardowych typów danych:

struktura Pozycja { x: i32, y: i32, } niech punkt = Pozycja { x: 10, y: 20 };

Można tworzyć struktury struktury krotek (pola nienazwane) lub struktury z nazwanymi polami. Ponadto dodanie pub do pól, stają się one publiczne poza bieżącym modułem.

L wyliczenia Umożliwiają zdefiniowanie typu, który może być jednym z kilku wariantów, nawet ze skojarzonymi danymi:

enum Action { Jump, Move { x: i32, y: i32 }, Say(String), } let jump = Action::Jump; let mov = Action::Move { x: 5, y: 10 }; let speak = Action::Say(String::from("Witaj!"));

Wyliczenie opcji i bezpieczne przetwarzanie wartości opcjonalnych

W Ruście null nie istniejeZamiast tego Opcja enum aby wyrazić, czy wartość może być obecna (Jakaś(wartość)) lub nieobecny (żaden):

niech liczba = Some(42); niech nic: Opcja = None;

Aby pracować z opcją, należy rozpakować wartość za pomocą metod takich jak odwijać się() (uwaga, może się nie udać przy None) lub rozpakuj_lub(wartość_domyślna)Jeszcze lepiej jest użyć dopasowanie wzoru aby objąć wszystkie przypadki:

dopasuj numer { Some(n) => println!("Wartość wynosi {}", n), None => println!("Brak wartości"), }

Dopasowywanie wzorców i kontrola przepływu

El dopasowanie wzoru Jest to jeden z klejnotów Rust, pozwalający na bezpieczne i przejrzyste radzenie sobie z różnymi możliwościami przy pomocy operatora. mecz:

enum Attack { Cios, Miecz, Włócznia, Magia, } niech atak = Atak::Miecz; niech obrażenia = dopasuj atak { Atak::Cios => 5, Atak::Miecz => 12, Atak::Włócznia => 8, Atak::Magia => 20, };

Istnieje również lżejsza składnia z jeśli pozwolisz, przydatne, gdy interesuje nas tylko jeden konkretny przypadek:

jeśli niech Some(value) = option { println!("Wartość bieżąca: {}", value); }

Metody, powiązane funkcje i zamknięcia

Używanie słowa kluczowego implikować Możesz dodać metody i powiązane funkcje do struktur i wyliczeń. Na przykład:

struktura Point { x: i64, y: i64, } impl Point { fn new(x: i64, y: i64) -> Self { Self { x, y } } fn move_to(&mut self, other: Point) { self.x = other.x; self.y = other.y; } }

Te zamknięcia lub anonimowe funkcje pozwalają na przechwytywanie zmiennych środowiskowych. Są one definiowane za pomocą |parametry|:

niech współczynnik = 10; niech per_factor = |x: i32| x * współczynnik; niech wynik = per_factor(5); // 50

Automatyczne testowanie w Rust

Rust jest wyposażony w system zintegrowane testowanie. Pozwala na tworzenie funkcji testowych obok kodu produkcyjnego:

fn add(a: i32, b: i32) -> i32 { a + b } #[cfg(test)] mod tests { użyj super::*; #[test] fn basic_sum() { assert_eq!(sum(2, 3), 5); } }

Aby je uruchomić, wystarczy wpisać:

test ładunku

Spowoduje to uruchomienie wszystkich testów i wyświetlenie wyników w konsoli, co pozwoli wykryć błędy zanim dotrą do produkcji.

Zasoby do nauki języka Rust i interaktywne przykłady

Jeśli chcesz nauczyć się Rusta w praktyce, znajdziesz mnóstwo oficjalnych i społecznościowych źródeł:

• Język programowania Rust: oficjalna, bezpłatna i aktualizowana książka, przewodnik krok po kroku od podstaw do kompletnych projektów.
• Przykłady kodu interaktywnego: Platformy takie jak Comprehensive Rust pozwalają eksperymentować i edytować przykłady bezpośrednio w przeglądarce, dzięki czemu nauka języka jest łatwiejsza i nie wymaga instalowania niczego poza kompilatorem.
• Ćwiczenia praktyczne: Wiele dzisiejszych poradników koncentruje się na nauce przez praktykę, od projektów konsolowych po tworzenie małych aplikacji internetowych i skryptów automatyzacji.
• Fora i społeczności: Społeczność Rust jest bardzo aktywna, udostępnia przestrzenie przeznaczone na odpowiadanie na pytania, przeglądy kodu oraz wydarzenia takie jak spotkania i konferencje.

Przykłady interaktywne często obejmują bloki kodu, takie jak:

fn main() { println!("Edytuj mnie!"); }

Warto skorzystać z tych interaktywnych środowisk, aby bez obaw testować i modyfikować kod oraz natychmiast oglądać rezultaty.

Rdza w obecnym ekosystemie: integracja i przypadki użycia

Rust nie jest tylko do aplikacji konsolowych. Coraz więcej firm i osób przyjmuje go do systemów wbudowanych, integracji z innymi językami (takimi jak Node.js za pośrednictwem Neon lub Python z PyO3), tworzeniem zaplecza internetowego (z frameworkami takimi jak Rocket lub Actix), a nawet tworzeniem OS kompletny.

Wiodące firmy i organizacje, takie jak Mozilla i Dropbox, wybrały Rust do projektów o znaczeniu krytycznym, szczególnie ceniąc jego niezawodność, zapobieganie błędom w czasie wykonywania i wyjątkową wydajność.

Możliwość kompilacji dla wielu architektur i platform, a także system zależności zarządzany przez Cargo i godna pozazdroszczenia dokumentacja sprawiają, że Rust jest wszechstronnym wyborem dla każdego rodzaju programowania.