Przewodnik dla początkujących po Rust: Od gry do programowania, szybkie zapoznanie się z ekosystemem Rust

Rust rozwija się bardzo szybko i jest czymś więcej niż tylko językiem programowania, to także dynamiczny ekosystem. Od gier survivalowych po wysokowydajne programowanie systemowe, Rust jest wszechobecny. Ten artykuł, bazując na dyskusjach na X/Twitterze, oferuje przewodnik szybkiego startu dla początkujących w Rust, obejmujący przypadki użycia Rust, zasoby do nauki i kilka przydatnych narzędzi.

I. Co to jest Rust? Dlaczego warto się go uczyć?

Rust to język programowania systemowego, który koncentruje się na bezpieczeństwie, szybkości i współbieżności. Ma na celu rozwiązanie typowych problemów z bezpieczeństwem pamięci w C i C++, oferując jednocześnie wydajność porównywalną, a nawet wyższą niż te języki.

Zalety Rust:

• Bezpieczeństwo pamięci: System własności i sprawdzanie zapożyczeń w Rust zapobiegają problemom takim jak wskaźniki null i wyścigi danych w czasie kompilacji.
• Wysoka wydajność: Rust kompiluje się do wydajnego kodu maszynowego i ma potężne możliwości abstrakcji bez kosztów.
• Bezpieczeństwo współbieżności: System typów Rust zapewnia bezpieczeństwo kodu współbieżnego, unikając wyścigów danych.
• Wieloplatformowość: Rust obsługuje wiele systemów operacyjnych i architektur, w tym Windows, Linux, macOS, WebAssembly itp.
• Aktywna społeczność: Rust ma dynamiczną społeczność, która oferuje bogactwo bibliotek, narzędzi i wsparcia.

Przypadki użycia Rust:

• Systemy operacyjne i systemy wbudowane: Ze względu na wysoką wydajność i bezpieczeństwo, Rust doskonale nadaje się do tworzenia jąder systemów operacyjnych, sterowników i oprogramowania urządzeń wbudowanych.
• WebAssembly (Wasm): Rust można skompilować do Wasm, umożliwiając uruchamianie wysokowydajnego kodu w przeglądarce.
• Narzędzia wiersza poleceń: Rust oferuje potężne frameworki do tworzenia narzędzi wiersza poleceń, takie jak clap i structopt.
• Programowanie sieciowe: Biblioteka tokio w Rust zapewnia asynchroniczne środowisko uruchomieniowe, które ułatwia pisanie wysokowydajnych aplikacji sieciowych.
• Tworzenie gier: Chociaż nie jest tak popularny jak C++, Rust zyskuje na popularności w dziedzinie tworzenia gier. Na przykład, otwarta gra survivalowa Rust sama w sobie jest rozwijana przy użyciu silnika Unity i C#, ale część logiki po stronie serwera można zoptymalizować za pomocą Rust.

II. Od gry Rust do języka programowania Rust

Dyskusja na X/Twitterze wspomniała o grze survivalowej Rust, która jest nierozerwalnie związana z językiem programowania Rust. Chociaż używają tej samej nazwy, są to różne rzeczy. Gra Rust to gra survivalowa dla wielu graczy online, a Rust to język programowania służący do tworzenia różnego rodzaju oprogramowania.

Gra Rust:

• To gra survivalowa dla wielu graczy online, w której gracze muszą przetrwać na pustkowiu, budować bazy i wchodzić w interakcje z innymi graczami.
• Jest rozwijana przy użyciu silnika Unity i C#.
• Można ją kupić na Steamie i często są na nią promocje.

Język programowania Rust:

• Służy do tworzenia różnego rodzaju oprogramowania, w tym systemów operacyjnych, silników przeglądarek, serwerów sieciowych, gier itp.
• Jest open source i wieloplatformowy.
• Ma potężny system typów i funkcje bezpieczeństwa pamięci.

Jeśli jesteś graczem w grę Rust i chcesz nauczyć się języka programowania Rust, możesz rozważyć następujące kroki:

1. Zainstaluj łańcuch narzędzi Rust: Pobierz i zainstaluj rustup ze strony , jest to narzędzie do zarządzania wersjami Rust.
2. Naucz się podstaw Rust: Przeczytaj oficjalny samouczek "The Rust Programming Language" (powszechnie znany jako "The Book"), aby dowiedzieć się o podstawowej składni Rust, systemie własności, sprawdzaniu zapożyczeń itp.
3. Projekty praktyczne: Utrwal zdobytą wiedzę, pisząc proste narzędzia wiersza poleceń, serwery WWW lub gry.
4. Dołącz do społeczności: Dołącz do społeczności Rust, komunikuj się z innymi programistami Rust i ucz się z ich doświadczeń. Konfiguracja środowiska programistycznego Rust jest bardzo prosta, wystarczy zainstalować rustup. rustup automatycznie zainstaluje kompilator Rust, bibliotekę standardową i inne niezbędne narzędzia.

Kroki:

1. Pobierz rustup: Odwiedź , aby pobrać odpowiedni instalator rustup dla Twojego systemu operacyjnego.
2. Uruchom instalator: Postępuj zgodnie z instrukcjami instalatora.
3. Skonfiguruj zmienne środowiskowe: rustup automatycznie skonfiguruje zmienne środowiskowe, ale możesz je również skonfigurować ręcznie.
4. Zweryfikuj instalację: Otwórz terminal i uruchom rustc --version oraz cargo --version. Jeśli poprawnie wyświetlą się numery wersji, oznacza to, że instalacja zakończyła się sukcesem.

Przykład kodu:

rustc --version  # Sprawdź wersję kompilatora Rust
cargo --version  # Sprawdź wersję menedżera pakietów Cargo

IV. Szybki start z podstawową składnią Rust

Poniżej znajduje się kilka podstawowych elementów składni Rust, które pomogą Ci szybko zacząć:

• Deklaracja zmiennych:

  let x = 5;          // Zmienna niemutowalna (niezmienna)
  let mut y = 10;     // Zmienna mutowalna (zmienna)
  const PI: f64 = 3.1415926; // Stała
  

• Typy danych:

  • Typy całkowite: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize

  • Typy zmiennoprzecinkowe: f32, f64

  • Typ logiczny: bool (true, false)

  • Typ znakowy: char (znak Unicode)

  • Typ łańcuchowy: String, &str

  • Krotka: (i32, f64, char)

  • Tablica: [i32; 5]

  • Wycinek: &[i32]

  • Struktura:

    struct Point {
        x: i32,
        y: i32,
    }
    

  • Wyliczenie:

    enum Color {
        Red,
        Green,
        Blue,
    }
    

• Funkcje:

  fn add(x: i32, y: i32) -> i32 {
      x + y
  }
  

• Przepływ sterowania:

  • Instrukcja if:

    if x > 5 {
        println!("x is greater than 5");
    } else if x == 5 {
        println!("x is equal to 5");
    } else {
        println!("x is less than 5");
    }
    

  • Pętla loop:

    loop {
        println!("This will loop forever");
        break; // Wyjście z pętli
    }
    ```## I. Wprowadzenie
    

Rust to nowoczesny język programowania systemów, który koncentruje się na bezpieczeństwie, szybkości i współbieżności. Został zaprojektowany, aby zapobiegać błędom, takim jak dereferencje null i wyścigi danych, jednocześnie oferując wydajność porównywalną z C i C++.

II. Konfiguracja środowiska

1. Instalacja Rust:

   • Użyj rustup, oficjalnego narzędzia do zarządzania wersjami Rust. Otwórz terminal i uruchom:

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

   • Postępuj zgodnie z instrukcjami wyświetlanymi na ekranie.

2. Sprawdź instalację:

   rustc --version
   cargo --version
   

   • Powinny zostać wyświetlone wersje kompilatora Rust (rustc) i menedżera pakietów Cargo.

III. Podstawowa składnia

1. "Hello, World!"

   • Utwórz plik main.rs:

   fn main() {
       println!("Hello, World!");
   }
   

   • Skompiluj i uruchom:

   rustc main.rs
   ./main
   

2. Zmienne i typy danych:

   • Rust to język statycznie typowany, ale często może wywnioskować typy.

   let x = 5; // niemutowalna zmienna (immutable)
   let mut y = 10; // mutowalna zmienna (mutable)
   y = 20;
   
   const Z: i32 = 15; // stała (constant)
   
   let a: i32 = 32; // liczba całkowita 32-bitowa ze znakiem (signed integer)
   let b: f64 = 2.5; // liczba zmiennoprzecinkowa 64-bitowa (floating-point number)
   let c: bool = true; // wartość logiczna (boolean)
   let d: char = 'A'; // znak (character)
   let e: &str = "Hello"; // łańcuch znaków (string slice)
   let f: String = String::from("World"); // łańcuch znaków (String)
   

3. Funkcje:

   fn add(x: i32, y: i32) -> i32 {
       x + y // brak średnika oznacza zwrócenie wartości (no semicolon means return)
   }
   
   fn main() {
       let result = add(5, 3);
       println!("Result: {}", result);
   }
   

4. Własność (Ownership), Pożyczanie (Borrowing) i Cykle życia (Lifetimes):

   • Własność: Każda wartość w Rust ma zmienną, która jest jej właścicielem. Może być tylko jeden właściciel na raz. Kiedy właściciel wychodzi poza zakres, wartość jest zwalniana.

   fn main() {
       let s1 = String::from("hello"); // s1 staje się właścicielem łańcucha znaków (s1 becomes the owner of the string)
       let s2 = s1; // s1 zostaje przeniesione do s2, s1 staje się nieważne (s1 is moved to s2, s1 becomes invalid)
       // println!("{}", s1); // Błąd: wartość została przeniesiona (Error: value borrowed here after move)
       println!("{}", s2);
   }
   

   • Pożyczanie: Pozwala na dostęp do wartości bez przejmowania własności. Używa referencji (&).

   fn main() {
       let s1 = String::from("hello");
       let len = calculate_length(&s1); // pożyczamy s1 (borrow s1)
       println!("The length of '{}' is {}.", s1, len);
   }
   
   fn calculate_length(s: &String) -> usize {
       s.len()
   } // s wychodzi poza zakres, ale ponieważ nie ma własności, nic nie jest zwalniane (s goes out of scope, but because it does not have ownership, nothing is dropped)
   

   • Mutowalne referencje: Pozwalają na modyfikację pożyczonej wartości.

   fn main() {
       let mut s = String::from("hello");
       change(&mut s);
       println!("{}", s);
   }
   
   fn change(s: &mut String) {
       s.push_str(", world");
   }
   

   • Cykle życia: Zapobiegają używaniu referencji, które wskazują na dane, które już zostały zwolnione. Kompilator Rust używa sprawdzania cykli życia, aby zapewnić, że referencje są zawsze ważne.

5. Struktury (Structs) i Enumy (Enums):

   • Struktury:

   struct Rectangle {
       width: u32,
       height: u32,
   }
   
   impl Rectangle {
       fn area(&self) -> u32 {
           self.width * self.height
       }
   }
   
   fn main() {
       let rect1 = Rectangle {
           width: 30,
           height: 50,
       };
   
       println!("The area of the rectangle is {} square pixels.", rect1.area());
   }
   

   • Enumy:

   enum IpAddrKind {
       V4(String),
       V6(String),
   }
   
   fn main() {
       let home = IpAddrKind::V4(String::from("127.0.0.1"));
       let loopback = IpAddrKind::V6(String::from("::1"));
   }
   

6. Obsługa błędów:

   • Rust używa Result do obsługi błędów, które mogą wystąpić.

   use std::fs::File;
   use std::io::ErrorKind;
   
   fn main() {
       let f = File::open("hello.txt");
   
       let f = match f {
           Ok(file) => file,
           Err(error) => match error.kind() {
               ErrorKind::NotFound => match File::create("hello.txt") {
                   Ok(fc) => fc,
                   Err(e) => panic!("Problem creating the file: {:?}", e),
               },
               other_error => {
                   panic!("Problem opening the file: {:?}", other_error)
               }
           },
       };
   }
   

IV. Przepływ sterowania

1. if-else:

   fn main() {
       let number = 7;
   
       if number < 5 {
           println!("condition was true");
       } else {
           println!("condition was false");
       }
   }
   

2. Pętle:

   • loop:

   fn main() {
       let mut counter = 0;
   
       let result = loop {
           counter += 1;
   
           if counter == 10 {
               break counter * 2;
           }
       };
   
       println!("The result is {}", result);
   }
   

   • while pętla:

   fn main() {
       let mut i = 0;
       while i < 5 {
           println!("value is: {}", i);
           i += 1;
       }
   }
   

   • for pętla:

   fn main() {
       let a = [10, 20, 30, 40, 50];
   
       for element in a.iter() {
           println!("the value is: {}", element);
       }
   }
   

3. match:

   fn main() {
       let number = 3;
   
       match number {
           1 => println!("one!"),
           2 => println!("two!"),
           3 => println!("three!"),
           _ => println!("something else!"),
       }
   }
   

V. Narzędzia i zasoby do nauki

• Cargo: Menedżer pakietów i narzędzie do budowania Rust, używane do zarządzania zależnościami, budowania projektów i uruchamiania testów.
• Rust Analyzer: Potężny serwer języka Rust, który oferuje uzupełnianie kodu, sprawdzanie składni, refaktoryzację i inne funkcje. Zalecane jest zainstalowanie odpowiedniej wtyczki w VS Code.
• Clippy: Narzędzie do statycznej analizy kodu Rust, które może sprawdzać potencjalne problemy w kodzie i oferować sugestie dotyczące ulepszeń.
• crates.io: Repozytorium pakietów Rust, podobne do npm (JavaScript) lub PyPI (Python).
• Oficjalna dokumentacja: Zawiera kompletną dokumentację języka Rust.
• Rust by Example: Zawiera wiele przykładów kodu Rust.
• The Rust Programming Language (The Book): Oficjalny podręcznik Rust, gorąco polecany do przeczytania.
• Rustlings: Interaktywne narzędzie do nauki Rust, które uczy Rust poprzez rozwiązywanie serii ćwiczeń.
• Kursy online: Istnieje wiele kursów online Rust na platformach takich jak Udemy, Coursera itp.

VI. Kierunki dalszej nauki

• Programowanie asynchroniczne (async/await): Użyj tokio lub async-std do pisania wysokowydajnych programów współbieżnych.
• WebAssembly (Wasm): Skompiluj kod Rust do Wasm, aby uruchomić go w przeglądarce.
• Programowanie wbudowane: Użyj Rust do tworzenia oprogramowania systemów wbudowanych.
• Rozwój blockchain: Użyj Rust do tworzenia aplikacji blockchain, takich jak rozwój inteligentnych kontraktów Solana.

VII. PodsumowanieRust to język programowania, który jest pełen wyzwań, ale także niezwykle wartościowy. Oferuje potężne bezpieczeństwo i wydajność oraz posiada aktywną społeczność. Mam nadzieję, że dzięki temu wprowadzeniu pomożemy Ci szybko rozpocząć przygodę z Rustem i rozpocząć Twoją podróż w programowaniu w Rust. Wychodząc od gry Rust, odkryj tajemnice języka programowania Rust, a odkryjesz zupełnie nowy świat.