Ön fejlesztő, aki Rust-ot szeretne tanulni? A döntés megkönnyítése érdekében ez a cikk bemutatja a Rust, az egyik legnépszerűbb rendszerprogramozási nyelv néhány funkcióját.
Ebben a cikkben megvizsgáljuk a Rust programozási nyelvet és annak jellemzőit, például a típusrendszert, a memóriabiztonságot és a tulajdonjogot. Áttekintjük azon források listáját is, amelyek segíthetnek a Rust elsajátításában.
Kezdjük!
Tartalomjegyzék
Mi az a Rust?
A Rust egy rendszerprogramozási nyelv. Graydon Hoare, egy fejlesztő személyes projektjeként indult még 2006-ban. Kevesebb, mint egy évtized alatt a rendszerprogramozás és a kapcsolódó alkalmazások legnépszerűbb választásává nőtte ki magát. Egy Rust programozó átlagos fizetése körülbelül 120 000 dollár.
Tehát ha C++-ról Rust-ra szeretne váltani, vagy új nyelvet szeretne elsajátítani, a Rust tanulása nagyszerű választás lehet! A StackOverflow Developer felmérése szerint a Rustot választották a legkedveltebb programozási nyelvnek – sorozatban hét éve.
Kép forrása: StackOverflow
A Rust az alacsony szintű rendszerprogramozási nyelvek, például a C és a C++ sebességét, valamint a magas szintű programozási nyelvek, például a Python biztonságát kínálja.
Az olyan figyelemre méltó projektektől, mint a Dropbox és a Firefox, a WebAssembly-ig és a beágyazott programozásig a Rustot széles körben használják a szoftverfejlesztés minden területén. A Rust azonnali csomagkezelési támogatást kínál a Cargo-n keresztül.
Rakomány: A Rust csomagkezelője
A Cargo a Rust csomagkezelője. A rakomány segítségével csomagokat telepíthet ládákból, a Rust csomagnyilvántartásból. Amellett, hogy csomagkezelő, amely lehetővé teszi a csomagok keresését, telepítését és kezelését, a cargo tesztfuttatóként, dokumentumgenerátorként és összeállítási rendszerként is szolgál.
Most, hogy áttekintést kapott a Rustról, nézzük meg közelebbről a Rust néhány olyan funkcióját, amelyek kiemelik, mint széles körben elterjedt rendszerprogramozási nyelvet.
Hasznos hibaüzenetek
Kezdő programozóként hibákba ütközhet, és sok időt tölt a kód hibakeresésével. A problémák megoldásához használja a fordító által biztosított hibaüzeneteket és figyelmeztetéseket. A hasznos üzenetek pedig segíthetnek a gyorsabb hibakeresésben.
Példa hibaüzenetre
Ha a kód fordítása nem sikeres, a Rust hasznos hibaüzeneteket ad, amelyek magyarázatot adnak arról, hogy mit és hol kell javítani a kódban.
Ebben a példában a num2 változó az inner() függvényen belül van definiálva. Ezért a funkció hatókörére korlátozódik. Ha a függvényen kívül próbálja elérni, a fordító hibát jelez:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
A hibaüzenet pedig információt ad arról, hogy mit kell javítani.
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`
Figyelmeztetések a fordítás során
A fordító hasznos figyelmeztetéseket is ad a kóddal kapcsolatos problémákkal kapcsolatban. Ha változókat definiál, de soha nem használja őket a program többi részében, a Rust figyelmeztető üzenetet ad, az ábrán látható módon.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Itt a num2 változó deklarálva van, de soha nem használjuk.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Erősen gépelt nyelv
A másik ok, amiért érdemes a Rust-ot használni fejlesztési projektjeihez, a típusrendszer. A Rust egy erősen tipizált nyelv, ami azt jelenti, hogy nem támogatja a típuskényszert. Típuskényszerről van szó, amikor egy nyelv implicit módon képes egy adattípusban lévő értéket egy másikra konvertálni.
Például a következő kódcellában található Python-kód hiba nélkül fog futni. Ennek az az oka, hogy Pythonban a nullától eltérő számok igazságértéke True, ezért az if utasítás hiba nélkül fut – annak ellenére, hogy a 10 egész szám – és nem logikai érték.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
Másrészt a Rust nem kényszeríti a típusokat. Tehát a következő kód hibát fog kiadni:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
A hiba típus eltérést jelez, ahol logikai értéket vártak, és egész számot találtunk.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
A memória biztonsága
A memóriabiztonság a Rust másik olyan tulajdonsága, amely vonzóvá teszi a programozók számára. Megpróbálunk egy felületes áttekintést adni ennek működéséről.
A változókat használat előtt inicializálni kell
A Rust alkalmazásban minden változót inicializálni kell, mielőtt felhasználható lenne. Az olyan nyelvekben, mint a C, a következő kód, ahol a num nincs inicializálva, lefordítja és hiba nélkül fut. Az inicializálatlan változó értéke valamilyen szemét érték.
#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
Ha megpróbálsz valami hasonlót csinálni a Rustban, fordítási idejű hibába fogsz futni. A rozsdának ezért fogalma sincs a szemétgyűjtésről.
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
|
Memóriabiztonság fordítási időben
A rozsda gondoskodik a memória biztonságáról a fordítási időben. Vegyünk egy egyszerű példát. Itt annak ellenére, hogy az if feltételes utasítás igaz logikai értékkel rendelkezik, ami azt jelenti, hogy a num értéke mindig 100 lesz, hibát kapunk, amikor megpróbáljuk kinyomtatni a szám értékét.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Ennek az az oka, hogy a feltételes kiértékelés futási időben történik, és a fordító nem tudja garantálni, hogy a num értéke fordításkor van.
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
Ha közelebbről megnézi a hibaüzenetet, látni fogja, hogy egy else utasítással biztosíthatjuk, hogy a num értéke legyen. Tehát a következő kód hiba nélkül fog futni. Mivel így a fordító meg tudja határozni, hogy a numnak értéke lesz – fordítási időben –, így nincs hiba.
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
Változók megváltoztathatatlansága
Azt is hasznos megjegyezni, hogy a Rust változói alapértelmezés szerint változtathatatlanok. Ez azt jelenti, hogy fejlesztőként nem kell attól tartania, hogy véletlenül felülírja egy adott változó értékét. Íme egy példa:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Mivel a num1 inicializálása 10, amikor 5-ös értéket próbál hozzárendelni, egy hibaüzenet jelenik meg, amely így szól: „Nem lehet kétszer hozzárendelni a num1 megváltoztathatatlan változóhoz”.
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
Tulajdonjog és kölcsönfelvétel
A tulajdonjog garantálja a memória biztonságát. Funkcionálisan a Rust tulajdonjogát a következőképpen lehet összefoglalni:
Minden tárgynak csak egy tulajdonosa kell, hogy legyen. Ha a tulajdonos kilép a hatókörből, akkor az objektumot eldobják.
Vegyünk egy egyszerű példát. Itt inicializálunk egy str1 karakterláncot, majd áthelyezzük az értékét str2-re. Mivel minden objektumnak csak egy tulajdonosa lehet, az str1 objektumot a rendszer eldobja, amint az értéke str2-be kerül.
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
Bár ez intuitívnak tűnik, a tulajdonjog működésének jobb megértése és értékelése érdekében hasznos megtanulni a kölcsönzés és a hivatkozás fogalmát.
Gyors fejlesztés
Eddig a Rust programozási nyelv számos hasznos funkcióját tárgyaltuk. Néhány áttekintéshez:
- A rozsda a sebesség és a biztonság szempontjából egyaránt optimalizált.
- Beépített csomagkezelő eszközzel érkezik, és rendszert épít fel.
- Gazdag szabványkönyvtárral is rendelkezik.
A Rust lényegében mindent kínál, amit egy fejlesztő kérhet. Ezért a Rust segítségével gyorsan fejleszthet alkalmazásokat minimális hibakereséssel és gyorsabb összeállítással.
Platformok közötti fejlesztés
A Rust segítségével választhat, hogy az általa választott platformon fejleszt. A Rust a leggyakoribb platformokat támogatja: Linux, MacOS és Windows.
Az alkalmazásfejlesztés általában egyszerű, mivel a Rust forráskódot végrehajthatóvá fordíthatja anélkül, hogy más összeállítási eszközöktől és külső fordítóktól függne.
A támogató közösség nagyban leegyszerűsíti a tanulási utat. A Rust hatalmas felhasználói bázissal rendelkezik, amely évről évre csak növekszik.
A Rust népszerűsége a StackOverflow fejlesztői felmérésben azt jelzi, hogy a felhasználók nagy közössége van, és sok tapasztalt fejlesztő hajlandó megosztani tudását és szakértelmét.
A hivatalos dokumentáción kívül van egy felhasználó által generált dokumentációs oldal és egy vitafórum is. A vonatkozó vitákat a Rust subreddit és a LinkedIn csoportokban is megnézheti.
Oktatási források a Rust használatának megkezdéséhez
Ez a rész felsorol néhány hasznos forrást a Rust használatának megkezdéséhez. Ez a lista nem kimerítő, de tartalmaz néhány ajánlott oktatóanyagot, tanfolyamot és könyvet, amelyek segítenek a tanulásban.
#1. Rozsda Példa szerint
A Rust By példa megtanítja Önnek a Rust alapjait és a szabványos könyvtárakat egy sor példán keresztül, amelyeket egy online szerkesztőben kódolhat.
A tárgyalt témák közé tartoznak a ládák, a rakomány: a Rust csomagkezelő eszköze, az általánosságok, a tulajdonságok, a hibakezelés és még sok más.
#2. Susogás
A Rustlings egy másik hivatalos tanulási forrás a Rust programozási nyelvhez. Példával hasonlít a Rusthoz. Ehhez azonban be kell állítania a helyi fejlesztési környezetet, klónozni kell egy példatárat, és egyszerű problémákat kell megoldania, hogy megtanulja ezeket a fogalmakat.
#3. Gyakorlati rozsdapálya
A Rust Track on Exercism több mint 100 gyakorlatot tartalmaz, amelyek segítenek megtanulni és tesztelni a rozsda megértését. Az Exercism egy ingyenes platform, ahol tapasztalt programozóktól kaphat mentorálást a gyakorlatok kódolása mellett.
#4. Ultimate Rust Crash Course
Az Ultimate Rust Crash Course, amelyet Nathan Stocks tanított az Udemy-n, a következőket fedi le:
- A Rust programozás alapjai
- Modulrendszer Rustban
- Adattípusok és vezérlési folyamat
- Referencia és kölcsönzés
- Struktúrák, tulajdonságok és gyűjtemények
#5. Ultimate Rust 2: Intermediate Concepts
Az Ultimate Rust 2 az Ultimate Rust Crash Course nyomon követése, és a következő témákat fedi le:
- Lezárások
- Iterátorok
- Hibakezelés
- Egység- és integrációs teszt
- Naplózás, többszálú feldolgozás és csatornák
#6. Rust lang: A teljes útmutató kezdőknek 2023-ra
Ez az Udemy-tanfolyam, amelyet Catalin Stefan tanít, egy átfogó kurzus a Rust programozásról. Néhány érintett téma a következőket tartalmazza:
- Rozsda alapjai
- Adattípusok, vezérlési struktúrák
- Funkciók, tulajdonságok
- Memóriakezelés
- Egyidejűség
#7. Programozási rozsda: gyors, biztonságos rendszerfejlesztés
A Rust programozása O’Reillytől egy népszerű Rust programozási könyv, amely a következőket tanítja meg:
- Alapvető adattípusok
- Tulajdonjog és hitelfelvétel
- Aszinkron programozás
- Gyors többszálú alkalmazások
- Lezárások, iterátorok
- Gyűjtemények
#8. The Rust programozási nyelv, 2. kiadás
A Rust programozási nyelv szerzői a Rust közösség neves közreműködői. Ez a könyv mindent tartalmaz, amit a Rustról tudni kell, beleértve:
- Tulajdonjog és hitelfelvétel
- Általánosságok, tulajdonságok
- Intelligens mutatók, többszálú
- Tesztelés és hibakezelés
#9. A teljes rozsdaprogramozási kézikönyv
A Packt teljes rozsdaprogramozási útmutatója a következőket tartalmazza:
- Adatstruktúrák megvalósítása a Rustban
- Újrafelhasználható és tesztelhető komponensek írása Rustban
- Többszálú alkalmazások tervezése algoritmus tervezés és
- A Rust alkalmazásai WebAssembly-ben, hálózati és parancssori alkalmazásokban
#10. Kreatív projektek Rust programozóknak
Ha Ön tapasztalt fejlesztő, aki a Rust nyelvet tanulja, akkor elegendő néhány projekt felépítése az Ön érdeklődési körébe tartozó területen, hogy megfelelő nyelvtudást szerezzen. A Packt Kreatív projektjei Rust programozóknak egy könyv, amely megtanítja Rust-ot azáltal, hogy ezeket olyan projektekre alkalmazza, mint:
- Nyugodt webszolgáltatások építése
- 2D játékok
- Webes alkalmazások fejlesztése a WebAssembly segítségével
- Gépi nyelv emulátorok
- és több!
Következtetés
Ez a cikk áttekintést nyújtott a Rustról mint rendszerprogramozási nyelvről, beleértve olyan funkciókat, mint a memóriabiztonság, a továbbfejlesztett csomagkezelés és egyebek. Felsoroltunk olyan tanulási forrásokat is, amelyek segítenek a Rust használatának megkezdésében.
Következő lépésként kiválaszthat egy vagy több említett tanulási forrást a Rust alapjainak megismeréséhez. Boldog Rust programozást!
Felfedezheti a legjobb Rust szerver hosting szolgáltatókat is.