Czy jesteś programistą, który chce nauczyć się języka Rust? Aby pomóc Ci w podjęciu decyzji, w tym artykule przedstawiono niektóre funkcje Rusta, jednego z najpopularniejszych języków programowania systemów.
W tym artykule przyjrzymy się językowi programowania Rust i jego cechom, takim jak system typów, bezpieczeństwo pamięci i własność. Omówimy również listę zasobów, które mogą pomóc w nauce Rusta.
Zaczynajmy!
Spis treści:
Co to jest rdza?
Rust to język programowania systemów. Zaczęło się jako osobisty projekt programisty Graydona Hoare’a w 2006 roku. W ciągu mniej niż dziesięciu lat stał się popularnym wyborem do programowania systemów i aplikacji pokrewnych. Średnia pensja programisty Rust wynosi około 120 000 $.
Więc jeśli chcesz przejść z C++ na Rust lub chcesz nauczyć się nowego języka, nauka Rusta może być świetnym wyborem! Według ankiety StackOverflow Developer, Rust został uznany za najbardziej lubiany język programowania – przez siedem lat z rzędu.
Źródło obrazu: StackOverflow
Rust oferuje szybkość języków programowania niskiego poziomu, takich jak C i C++, oraz bezpieczeństwo języków programowania wysokiego poziomu, takich jak Python.
Od znanych projektów, takich jak Dropbox i Firefox, po WebAssembly i programowanie wbudowane, Rust jest szeroko stosowany we wszystkich obszarach tworzenia oprogramowania. Rust oferuje gotową obsługę zarządzania pakietami za pośrednictwem Cargo.
Cargo: Menedżer pakietów dla Rust
Cargo jest menedżerem pakietów dla Rusta. Możesz użyć ładunku do instalowania pakietów ze skrzynek, rejestru pakietów Rust. Oprócz tego, że jest menedżerem pakietów, który umożliwia wyszukiwanie, instalowanie i zarządzanie pakietami, cargo służy również jako program do przeprowadzania testów, generator dokumentów i system kompilacji.
Teraz, gdy masz już ogólny zarys Rusta, przyjrzyjmy się bliżej niektórym cechom Rusta, które wyróżniają go jako język programowania systemów o szerokim zastosowaniu.
Pomocne komunikaty o błędach
Jako początkujący programista napotkasz błędy i spędzisz znaczną ilość czasu na debugowaniu kodu. Użyjesz komunikatów o błędach i ostrzeżeń dostarczonych przez kompilator, aby rozwiązać te problemy. Pomocne komunikaty mogą pomóc w szybszym debugowaniu.
Przykładowy komunikat o błędzie
Kiedy twój kod nie kompiluje się pomyślnie, Rust dostarcza pomocne komunikaty o błędach, które dostarczają wyjaśnień, co należy poprawić w twoim kodzie i gdzie.
W tym przykładzie zmienna num2 jest zdefiniowana wewnątrz funkcji inner(). Ogranicza się zatem do zakresu funkcji. Jeśli spróbujesz uzyskać do niego dostęp poza funkcją, kompilator zgłosi błąd:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Komunikat o błędzie zawiera informacje o tym, co należy naprawić.
error[E0425]: cannot find value `num2` in this scope
--> src/main.rs:6:42
|
6 | println!("The value of num2 is: {}", num2);
| ^^^^ help: a local variable with a similar name exists: `num1`
Ostrzeżenia podczas kompilacji
Kompilator udostępnia również przydatne ostrzeżenia dotyczące problemów w kodzie. Kiedy zdefiniujesz zmienne, ale nigdy nie użyjesz ich w pozostałej części programu, Rust wyświetli komunikat ostrzegawczy, jak pokazano.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Tutaj zmienna num2 jest zadeklarowana, ale nigdy nie jest używana.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Silnie typowany język
Innym powodem, dla którego powinieneś używać Rust do swoich projektów rozwojowych, jest jego system typów. Rust jest językiem mocno typowanym, co oznacza, że nie obsługuje wymuszania typów. Wymuszanie typu ma miejsce, gdy język może niejawnie przekonwertować wartość w typie danych na inny.
Na przykład kod Pythona w poniższej komórce kodu będzie działać bez błędów. Dzieje się tak dlatego, że w Pythonie liczba różna od zera ma wartość True, a zatem instrukcja if jest wykonywana bez błędów — nawet jeśli liczba 10 jest liczbą całkowitą — a nie wartością logiczną.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
Z drugiej strony Rust nie wymusza typów. Tak więc poniższy kod zgłosi błąd:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Błąd zgłasza niezgodność typu, gdzie oczekiwano wartości logicznej, a znaleziono liczbę całkowitą.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Bezpieczeństwo pamięci
Bezpieczeństwo pamięci to kolejna cecha Rusta, która czyni go atrakcyjnym dla programistów. Postaramy się przedstawić pobieżny przegląd tego, jak to działa.
Zmienne muszą zostać zainicjowane przed użyciem
W Rust wszystkie zmienne muszą zostać zainicjowane, zanim będą mogły być użyte. W językach takich jak C następujący kod, w którym num nie jest zainicjowany, skompiluje się i uruchomi bez błędów. Wartość niezainicjowanej zmiennej jest wartością śmieciową.
#include <stdio.h>
int main(void) {
int num;
printf("The value of num is %d", num);
return 0;
}
// Output: The value of num is 0
Jeśli spróbujesz zrobić coś podobnego w Rust, napotkasz błąd w czasie kompilacji. Dlatego Rust nie ma pojęcia o wyrzucaniu śmieci.
fn main() {
let num:i32;
println!("The value of num is: {}",num);
}
error[E0381]: used binding `num` isn't initialized
--> src/main.rs:3:40
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | println!("The value of num is: {}",num);
| ^^^ `num` used here but it isn't initialized
|
Bezpieczeństwo pamięci w czasie kompilacji
Rust zapewnia bezpieczeństwo pamięci w czasie kompilacji. Weźmy prosty przykład. Tutaj, mimo że instrukcja warunkowa if ma wartość logiczną true, co oznacza, że wartość num zawsze będzie wynosić 100, podczas próby wydrukowania wartości num pojawia się błąd.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Dzieje się tak, ponieważ ocena warunkowa występuje w czasie wykonywania, a kompilator nie będzie w stanie zagwarantować, że num ma wartość w czasie kompilacji.
error[E0381]: used binding `num` is possibly-uninitialized
--> src/main.rs:6:41
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | if true{
| ---- if this `if` condition is `false`, `num` is not initialized
4 | num = 100;
5 | }
| - an `else` arm might be missing here, initializing `num`
6 | println!("The value of num is: {}", num);
| ^^^ `num` used here but it is possibly-uninitialized
Jeśli przyjrzysz się bliżej komunikatowi o błędzie, zobaczysz, że za pomocą instrukcji else możemy zapewnić, że liczba będzie miała wartość. Tak więc poniższy kod będzie działał bez błędów. Ponieważ w ten sposób kompilator może ustalić, że liczba num będzie miała wartość — w czasie kompilacji — więc nie wystąpią żadne błędy.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("The value of num is: {}", num);
}
The value of num is: 100
Niezmienność zmiennych
Warto również zauważyć, że zmienne w Rust są domyślnie niezmienne. Oznacza to, że jako programista nie musisz się martwić o przypadkowe nadpisanie wartości określonej zmiennej. Oto przykład:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Ponieważ liczba num1 jest inicjowana na 10, przy próbie przypisania jej wartości 5 pojawia się komunikat o błędzie „nie można przypisać dwukrotnie do niezmiennej zmiennej num1”.
error[E0384]: cannot assign twice to immutable variable `num1` --> src/main.rs:3:5 | 2 | let num1 = 10; | ---- | | | first assignment to `num1` | help: consider making this binding mutable: `mut num1` 3 | num1 = 5; | ^^^^^^^^ cannot assign twice to immutable variable
Własność i pożyczka
Własność zapewnia bezpieczeństwo pamięci. Funkcjonalnie własność w Rust można podsumować w następujący sposób:
Każdy przedmiot powinien mieć jednego i tylko jednego właściciela. Jeśli właściciel wyjdzie poza zakres, obiekt zostanie usunięty.
Weźmy prosty przykład. Tutaj inicjujemy łańcuch str1, a następnie przenosimy jego wartość do str2. Ponieważ każdy obiekt może mieć tylko jednego właściciela, obiekt str1 jest usuwany, gdy tylko jego wartość zostanie przeniesiona do str2.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("The value of str1 is: {}", str1);
}
error[E0382]: borrow of moved value: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- move occurs because `str1` has type `String`, which does not implement the `Copy` trait
3 | let str2 = str1;
| ---- value moved here
4 | println!("The value of str1 is: {}", str1);
| ^^^^ value borrowed here after move
Chociaż wydaje się to intuicyjne, aby lepiej zrozumieć i docenić, jak działa własność, warto poznać koncepcje pożyczania i referencji.
Szybki rozwój
Do tej pory omówiliśmy kilka przydatnych funkcji języka programowania Rust. Aby przejrzeć kilka:
- Rust jest zoptymalizowany zarówno pod kątem szybkości, jak i bezpieczeństwa.
- Jest wyposażony we wbudowane narzędzie do zarządzania pakietami i buduje system.
- Posiada również bogatą bibliotekę standardową.
Zasadniczo Rust oferuje wszystko, o co może poprosić programista. Dlatego dzięki Rust możesz szybko tworzyć aplikacje przy minimalnym debugowaniu i szybszych kompilacjach.
Rozwój międzyplatformowy
Z Rust możesz wybrać programowanie na wybranej przez siebie platformie. Rust obsługuje najpopularniejsze platformy: Linux, MacOS i Windows.
Tworzenie aplikacji jest generalnie łatwe, ponieważ można skompilować kod źródłowy Rust do pliku wykonywalnego bez polegania na innych narzędziach do kompilacji i zewnętrznych kompilatorach.
Wspierająca społeczność znacznie upraszcza proces uczenia się. Rust ma ogromną bazę użytkowników, która rośnie z każdym rokiem.
Popularność Rust w ankiecie programistów StackOverflow wskazuje, że istnieje duża społeczność użytkowników, z wieloma doświadczonymi programistami, którzy chcą dzielić się swoją wiedzą i doświadczeniem.
Oprócz oficjalnej dokumentacji dostępna jest również witryna z dokumentacją generowaną przez użytkowników oraz forum dyskusyjne. Możesz także sprawdzić subreddit Rust i grupy LinkedIn, aby znaleźć odpowiednie dyskusje.
Zasoby szkoleniowe ułatwiające rozpoczęcie pracy z Rust
W tej sekcji wymieniono kilka pomocnych zasobów, które pomogą Ci rozpocząć pracę z Rust. To nie jest wyczerpująca lista, ale zawiera kilka zalecanych samouczków, kursów i książek, które pomogą Ci w Twojej podróży edukacyjnej.
# 1. Rdza na przykładzie
Rust By Example nauczy Cię podstaw Rusta i standardowych bibliotek poprzez serię przykładów, które możesz kodować w internetowym edytorze.
Omawiane tematy obejmują skrzynie, ładunki: narzędzie do zarządzania pakietami w Rust, rodzaje, cechy, obsługę błędów i wiele więcej.
#2. szelesty
Rustlings to kolejny oficjalny materiał do nauki języka programowania Rust. Na przykładzie jest podobny do Rusta. Wymaga to jednak skonfigurowania lokalnego środowiska programistycznego, sklonowania przykładowego repozytorium i rozwiązania prostych problemów, aby nauczyć się tych pojęć.
#3. Tor zardzewiały do ćwiczeń
Rust Track on Exercism zawiera ponad 100 ćwiczeń, które pomogą Ci nauczyć się i sprawdzić zrozumienie Rusta. Exercism to bezpłatna platforma, na której oprócz kodowania ćwiczeń możesz uzyskać porady doświadczonych programistów.
#4. Ostateczny kurs rdzy
The Ultimate Rust Crash Course, prowadzony przez Nathana Stocksa na Udemy, obejmuje:
- Podstawy programowania w języku Rust
- System modułów w Rust
- Typy danych i przepływ sterowania
- Referencje i pożyczki
- Struktury, cechy i kolekcje
#5. Ultimate Rust 2: Zaawansowane koncepcje
Ultimate Rust 2 jest kontynuacją kursu Ultimate Rust Crash Course i obejmuje następujące tematy:
- Domknięcia
- Iteratory
- Obsługa błędów
- Test jednostkowy i integracyjny
- Logowanie, wielowątkowość i kanały
#6. Rust lang: Kompletny przewodnik dla początkujących 2023
Ten kurs Udemy, prowadzony przez Catalina Stefana, jest kompleksowym kursem programowania w języku Rust. Niektóre z poruszanych tematów to:
- Podstawy rdzy
- Typy danych, struktury kontrolne
- Funkcje, cechy
- Zarządzanie pamięcią
- Konkurencja
#7. Programowanie Rust: szybkie, bezpieczne tworzenie systemów
Programming Rust autorstwa O’Reilly to popularna książka o programowaniu w języku Rust, która nauczy Cię następujących rzeczy:
- Podstawowe typy danych
- Własność i pożyczka
- Programowanie asynchroniczne
- Szybkie aplikacje wielowątkowe
- Zamknięcia, iteratory
- Kolekcje
#8. Język programowania Rust, wydanie 2
Język programowania Rust jest autorstwa uznanych współpracowników społeczności Rust. Ta książka zawiera wszystko, co musisz wiedzieć o Ruście, w tym:
- Własność i pożyczka
- Rodzaje, cechy
- Inteligentne wskaźniki, wielowątkowość
- Testowanie i obsługa błędów
#9. Kompletny przewodnik po programowaniu w Rust
Kompletny przewodnik po programowaniu w języku Rust firmy Packt obejmuje:
- Implementacja struktur danych w Rust
- Pisanie komponentów wielokrotnego użytku i testowalnych w Rust
- Projektowanie aplikacji wielowątkowych projektowanie algorytmów i
- Zastosowania Rust w WebAssembly, aplikacjach sieciowych i wierszu poleceń
#10. Kreatywne projekty dla programistów Rusta
Jeśli jesteś doświadczonym programistą uczącym się języka Rust, wystarczy zbudować kilka projektów w interesującej Cię dziedzinie, aby dobrze opanować język. Creative Projects for Rust Programmers firmy Packt to książka, która uczy języka Rust, stosując je w projektach takich jak:
- Tworzenie Restfulowych serwisów internetowych
- gry 2D z
- Tworzenie aplikacji internetowych z wykorzystaniem WebAssembly
- Emulatory języka maszynowego
- i więcej!
Wniosek
W tym artykule przedstawiono przegląd Rust jako języka programowania systemów, w tym funkcje takie jak bezpieczeństwo pamięci, ulepszone zarządzanie pakietami i inne. Wyliczyliśmy również zasoby szkoleniowe, które pomogą Ci rozpocząć pracę z Rust.
W następnym kroku możesz wybrać jeden lub więcej z wymienionych zasobów edukacyjnych, aby poznać podstawy Rusta. Miłego programowania w Ruście!
Możesz także zapoznać się z najlepszymi dostawcami hostingu serwerów Rust.