7 důvodů, proč použít Rust pro váš další developerský projekt

autor:
Tweet
Share
Share
Pin

Rust: Proč byste se ho měli naučit jako vývojář?

Uvažujete o studiu programovacího jazyka Rust? Tento článek vám pomůže se rozhodnout. Představíme vám některé klíčové vlastnosti Rustu, který si získává popularitu jako jazyk pro systémové programování.

V tomto textu se podíváme na Rust a jeho charakteristiky, jako je typový systém, zabezpečení paměti a koncept vlastnictví. Také projdeme seznam zdrojů, které vám usnadní učení tohoto jazyka.

Pojďme na to!

Co je to Rust?

Rust je systémový programovací jazyk. Jeho historie se začala psát v roce 2006 jako osobní projekt vývojáře Graydona Hoarea. Během necelých deseti let se stal oblíbenou volbou pro systémové programování a související aplikace. Průměrný roční plat programátora Rust se pohybuje okolo 120 tisíc dolarů.

Jestliže tedy zvažujete přechod z C++ na Rust, nebo si jen chcete rozšířit obzory, může být studium Rustu skvělou investicí. Podle průzkumu StackOverflow Developer byl Rust opakovaně zvolen nejoblíbenějším programovacím jazykem – a to již sedm let po sobě.

Rust kombinuje rychlost nízkoúrovňových jazyků, jako je C a C++, s bezpečností jazyků vyšší úrovně, jako je Python.

Od velkých projektů jako Dropbox a Firefox, přes WebAssembly až po vestavěné systémy, Rust nachází uplatnění v mnoha oblastech vývoje software. Navíc, Rust nabízí přímou podporu pro správu balíčků pomocí nástroje Cargo.

Cargo: Správce balíčků pro Rust

Cargo je klíčový správce balíčků pro Rust. Můžete ho používat pro instalaci balíčků z crates.io, což je registr balíčků Rust. Kromě správy balíčků, včetně vyhledávání, instalace a aktualizace, Cargo slouží i jako nástroj pro spouštění testů, generování dokumentace a sestavování projektu.

Nyní, když máte základní představu o Rustu, se podíváme na některé jeho specifické vlastnosti, díky nimž je tak výjimečný v oblasti systémového programování a získává si stále větší popularitu.

Užitečné chybové zprávy

Jako začínající programátor se nevyhnete chybám a ladění kódu vám zabere nemalou část času. Chybové zprávy a varování od kompilátoru vám s tím ale mohou významně pomoci. Kvalitní chybové hlášení vám usnadní hledání a odstraňování chyb.

Příklad chybové zprávy

Pokud se váš kód nezkompiluje, Rust vám poskytne detailní chybové zprávy, které objasňují, co je potřeba v kódu opravit a kde se chyba nachází.

V následujícím příkladu je proměnná `num2` definována uvnitř funkce `inner()`, což omezuje její viditelnost na tuto funkci. Pokud se ji pokusíte použít mimo tuto funkci, kompilátor zobrazí chybu:


fn main() {
    let num1 = 10;
    fn inner(){
        let num2 = 9; 
    }
    println!("Hodnota num2 je: {}", num2);
}

Chybová zpráva poskytne přesné informace o tom, co je potřeba opravit.


error[E0425]: nelze najít hodnotu `num2` v tomto rozsahu
 --> src/main.rs:6:42
  |
6 |     println!("Hodnota num2 je: {}", num2);
  |                                          ^^^^ nápověda: existuje lokální proměnná s podobným názvem: `num1`

Varování během kompilace

Kompilátor také generuje užitečná varování, která upozorňují na potenciální problémy ve vašem kódu. Pokud například definujete proměnnou, ale nikde ji nepoužijete, Rust vám zobrazí varování, jak je vidět na následujícím příkladu.


fn main() {
    let num1 = 10;
    let num2 = 9;
    println!("Hodnota num1 je: {}", num1);
}

V tomto případě je proměnná `num2` deklarovaná, ale nikdy není použita.


warning: nepoužitá proměnná: `num2`
 --> src/main.rs:3:9
  |
3 |     let num2 = 9;
  |         ^^^^ nápověda: pokud je to záměr, předejte jí podtržítko: `_num2`
  |

Silně typovaný jazyk

Dalším důvodem, proč zvážit Rust pro vaše vývojářské projekty, je jeho typový systém. Rust je silně typovaný jazyk, což znamená, že nepodporuje implicitní konverze typů. K typové konverzi dochází, když jazyk automaticky převede hodnotu z jednoho datového typu na jiný.

Například v Pythonu následující kód poběží bez chyby. Důvodem je, že v Pythonu má nenulové číslo logickou hodnotu `True`, a proto podmínka `if` proběhne, ačkoli `10` je celé číslo, nikoliv boolean.


num1 = 10
if num1:
    num2 = 9
print(f"num2 is {num2}")

# Výstup: num2 is 9

Naopak, Rust automatické konverze typů nepovoluje. Následující kód tak vyvolá chybu:


fn main() {
    let num1 = 10;
    if num1{
        let num2 = 9; 
    }
}

Chyba hlásí neshodu typů, kde byla očekávána logická hodnota, ale bylo nalezeno celé číslo.


error[E0308]: neshoda typů
 --> src/main.rs:3:8
  |
3 |     if num1{
  |        ^^^^ očekáváno `bool`, nalezeno celé číslo

Bezpečnost paměti

Bezpečnost paměti je další významnou vlastností, která činí Rust atraktivním pro programátory. Pokusíme se stručně vysvětlit, jak funguje.

Proměnné musí být inicializovány před použitím

V Rustu musí být všechny proměnné inicializovány před tím, než je použijete. V jazycích jako C se následující kód, kde `num` není inicializována, zkompiluje a spustí bez chyby. Hodnota neinicializované proměnné je v tomto případě náhodná. 


#include <stdio.h>

int main(void) {
    int num;
    printf("Hodnota num je %d", num);
    return 0;
}
// Výstup: Hodnota num je 0

Pokud se pokusíte udělat něco podobného v Rustu, dojde k chybě při kompilaci. Rust totiž nemá automatickou garbage collection.


fn main() {
    let num:i32;
    println!("Hodnota num je: {}",num);
}
  

error[E0381]: použitá vazba `num` není inicializována
 --> src/main.rs:3:40
  |
2 |     let num:i32;
  |         --- vazba deklarovaná zde, ale ponechána neinicializovaná
3 |     println!("Hodnota num je: {}",num);
  |                                        ^^^ `num` použito zde, ale není inicializováno
  |

Bezpečnost paměti v době kompilace

Rust zajišťuje bezpečnost paměti v době kompilace. Vezměme si jednoduchý příklad. I když má podmínka `if` hodnotu `true`, což znamená, že hodnota `num` bude vždy 100, dostaneme chybu, pokud se pokusíme tuto hodnotu vypsat.


fn main() {
    let num:i32;
    if true{
        num = 100;
    }
    println!("Hodnota num je: {}", num);
}

Důvodem je, že podmíněné vyhodnocení se děje za běhu a kompilátor nemůže zaručit, že `num` má v době kompilace hodnotu.


error[E0381]: použitá vazba `num` je možná neinicializovaná
 --> src/main.rs:6:41
  |
2 |     let num:i32;
  |         --- vazba deklarovaná zde, ale ponechána neinicializovaná
3 |     if true{
  |        ---- pokud je tato podmínka `if` `false`, `num` není inicializovaná
4 |         num = 100;
5 |     }
  |      - zde by mohla chybět větev `else`, inicializující `num`
6 |     println!("Hodnota num je: {}", num);
  |                                         ^^^ `num` použito zde, ale je možná neinicializované

Pokud se blíže podíváte na chybovou zprávu, zjistíte, že přidáním větve `else` můžeme zajistit, že `num` bude mít vždy nějakou hodnotu. Následující kód tak poběží bez problémů. Tímto způsobem může kompilátor ověřit, že `num` bude mít hodnotu – v době kompilace – takže k chybám nedochází.


fn main() {
    let num:i32;
    if true{
        num = 100;
    }
    else{
        num = 50;
    }
    println!("Hodnota num je: {}", num);
}
  

Hodnota num je: 100

Neměnnost proměnných

Je také důležité zmínit, že proměnné v Rustu jsou implicitně neměnné. To znamená, že se jako vývojář nemusíte obávat náhodného přepsání hodnoty konkrétní proměnné. Zde je příklad:


fn main() {
    let num1 = 10;
    num1 = 5;
    println!("Hodnota num1 je: {}", num1);
}

Protože `num1` je inicializována na 10, pokud se jí pokusíte přiřadit hodnotu 5, zobrazí se chybová zpráva „nelze přiřadit dvakrát do neměnné proměnné `num1`“.


error[E0384]: nelze přiřadit dvakrát do neměnné proměnné `num1`
 --> src/main.rs:3:5
  |
2 |     let num1 = 10;
  |         ----
  |         |
  |         první přiřazení do `num1`
  |         nápověda: zvažte, zda by tato vazba měla být mutabilní: `mut num1`
3 |     num1 = 5;
  |     ^^^^^^^^ nelze přiřadit dvakrát do neměnné proměnné

Vlastnictví a výpůjčky

Mechanismus vlastnictví zajišťuje bezpečnost paměti. Funkčně lze vlastnictví v Rustu shrnout takto:

Každý objekt má mít jednoho a pouze jednoho vlastníka. Pokud vlastník přestane platit, objekt se zruší.

Vezměme si jednoduchý příklad. Zde inicializujeme řetězec `str1` a poté přesuneme jeho hodnotu do `str2`. Protože každý objekt může mít pouze jednoho vlastníka, objekt `str1` je zrušen, jakmile se jeho hodnota přesune do `str2`.


fn main() {
    let str1 = String::from("Rust");
    let str2 = str1;
    println!("Hodnota str1 je: {}", str1);
}
  

error[E0382]: vypůjčení přesunuté hodnoty: `str1`
 --> src/main.rs:4:42
  |
2 |     let str1 = String::from("Rust");
  |         ---- přesun proběhl, protože `str1` má typ `String`, který neimplementuje trait `Copy`
3 |     let str2 = str1;
  |                ---- hodnota přesunuta sem
4 |     println!("Hodnota str1 je: {}", str1);
  |                                          ^^^^ hodnota vypůjčena zde po přesunu

I když se to na první pohled může zdát neintuitivní, pro lepší pochopení a funkčnost vlastnictví je vhodné se naučit koncepty půjčování a referencí.

Rychlý vývoj

Doposud jsme probrali několik užitečných vlastností programovacího jazyka Rust. Zde je stručný přehled:

  • Rust je optimalizován jak pro rychlost, tak pro bezpečnost.
  • Má integrovaný nástroj pro správu balíčků a sestavování projektů.
  • Nabízí rozsáhlou standardní knihovnu.

Zkrátka, Rust poskytuje vše, co vývojář potřebuje. Díky Rustu můžete rychle vyvíjet aplikace s minimálním laděním a rychlejším procesem sestavení.

Vývoj napříč platformami

S Rustem si můžete vybrat platformu pro vývoj podle vašich potřeb. Rust podporuje nejrozšířenější platformy, jako jsou Linux, macOS a Windows.

Vývoj aplikací je obecně jednoduchý, protože můžete kompilovat zdrojový kód Rustu do spustitelného souboru bez nutnosti spoléhat na externí nástroje pro sestavení a kompilátory.

Silná komunita hraje klíčovou roli při usnadnění procesu učení. Rust má obrovskou uživatelskou základnu, která se každým rokem rozšiřuje.

Popularita Rustu v průzkumech StackOverflow naznačuje, že existuje velká komunita s mnoha zkušenými vývojáři, kteří jsou ochotni sdílet své znalosti a zkušenosti.

Kromě oficiální dokumentace je k dispozici také komunitní dokumentační web a diskusní fóra. Můžete se také podívat na Rust subreddit a LinkedIn skupiny pro relevantní diskuze.

Výukové materiály pro začátek s Rustem

V této části najdete několik užitečných zdrojů, které vám pomohou začít s Rustem. Nejedná se o vyčerpávající seznam, ale o doporučené výukové materiály, kurzy a knihy, které vám usnadní cestu k naučení se Rustu.

#1. Rust By Example

Rust By Example vás naučí základy Rustu a jeho standardní knihovny prostřednictvím série příkladů, které si můžete vyzkoušet v online editoru.

Témata zahrnují crates, cargo (nástroj pro správu balíčků pro Rust), generika, traits, řešení chyb a mnoho dalšího.

#2. Rustlings

Rustlings je dalším oficiálním výukovým zdrojem pro programovací jazyk Rust. Je to podobné jako Rust By Example. Budete si však muset nastavit místní vývojové prostředí, naklonovat demonstrační repozitář a řešit jednoduché problémy, abyste se naučili jednotlivé koncepty.

#3. Rust Track na Exercism

Rust Track na Exercism obsahuje více než 100 cvičení, která vám pomohou otestovat a prohloubit vaše znalosti Rustu. Exercism je bezplatná platforma, kde kromě kódování cvičení můžete získat zpětnou vazbu od zkušených programátorů.

#4. Ultimate Rust Crash Course

Kurz Ultimate Rust Crash, který vyučuje Nathan Stocks na platformě Udemy, zahrnuje:

  • Základy programování v Rustu
  • Modulární systém v Rustu
  • Datové typy a řízení toku programu
  • Reference a půjčování
  • Struktury, traity a kolekce

#5. Ultimate Rust 2: Koncepty pro středně pokročilé

Ultimate Rust 2 je navazující kurz na Ultimate Rust Crash Course a zabývá se následujícími tématy:

  • Uzávěry
  • Iterátory
  • Zpracování chyb
  • Unit a integrační testy
  • Logování, multithreading a kanály

#6. Rust lang: Kompletní průvodce pro začátečníky 2023

Tento kurz na Udemy, který vyučuje Catalin Stefan, je komplexním kurzem programování Rust. Některá z probíraných témat jsou:

  • Základy Rustu
  • Datové typy, řídicí struktury
  • Funkce, vlastnosti
  • Správa paměti
  • Konkurence

#7. Programming Rust: Rychlý, bezpečný vývoj systémů

Programming Rust od O’Reilly je populární kniha o programování v Rustu, která vás naučí:

  • Základní datové typy
  • Vlastnictví a půjčování
  • Asynchronní programování
  • Rychlé multi-threading aplikace
  • Uzávěry, iterátory
  • Kolekce

#8. Programovací jazyk Rust, 2. vydání

Kniha Programovací jazyk Rust je od renomovaných přispěvatelů z komunity Rust. Kniha obsahuje vše, co potřebujete o Rustu vědět, včetně:

  • Vlastnictví a půjčování
  • Generika, traits
  • Chytré ukazatele, multithreading
  • Testování a zpracování chyb

#9. Kompletní referenční příručka k programování Rust

Kompletní referenční příručka k programování Rust od společnosti Packt zahrnuje:

  • Implementaci datových struktur v Rustu
  • Psaní opakovaně použitelných a testovatelných komponent v Rustu
  • Návrh multi-threaded aplikací, návrh algoritmů a
  • Aplikace Rustu ve WebAssembly, sítích a aplikacích příkazového řádku

#10. Kreativní projekty pro programátory Rust

Pokud jste zkušený vývojář, který se učí Rust, k dobrému pochopení jazyka stačí vybudovat několik projektů ve vaší oblasti zájmu. Creative Projects for Rust Programmers od společnosti Packt je kniha, která učí Rust pomocí projektů, jako jsou:

  • Tvorba Restful webových služeb
  • 2D hry
  • Vývoj webových aplikací pomocí WebAssembly
  • Emulátory strojového kódu
  • a další!

Závěr

Tento článek poskytl přehled o Rustu jako systémovém programovacím jazyku, včetně jeho vlastností, jako je bezpečnost paměti, vylepšená správa balíčků a další. Také jsme zmínili výukové zdroje, které vám mohou pomoci začít s Rustem.

Jako další krok si můžete vybrat jeden nebo více zmíněných výukových zdrojů, abyste si osvojili základy Rustu. Přejeme vám příjemné programování v Rustu!

Můžete také prozkoumat některé z nejlepších poskytovatelů hostingu Rust serverů.