Er du en udvikler, der ønsker at lære Rust? For at hjælpe dig med at beslutte præsenterer denne artikel nogle af funktionerne i Rust, et af de mest populære systemprogrammeringssprog.
I denne artikel vil vi udforske Rust-programmeringssproget og dets funktioner, såsom typesystem, hukommelsessikkerhed og ejerskab. Vi vil også gennemgå en liste over ressourcer, der kan hjælpe dig med at lære Rust.
Lad os begynde!
Indholdsfortegnelse
Hvad er rust?
Rust er et systemprogrammeringssprog. Det startede som et personligt projekt af Graydon Hoare, en udvikler, tilbage i 2006. På mindre end et årti er det vokset til det foretrukne valg for systemprogrammering og beslægtede applikationer. Den gennemsnitlige løn for en Rust-programmør er omkring $120K.
Så hvis du ønsker at skifte fra C++ til Rust eller ønsker at vælge et nyt sprog, kan det være et godt valg at lære Rust! Ifølge StackOverflow Developer-undersøgelsen er Rust blevet kåret som det mest elskede programmeringssprog – syv år i træk.
Billedkilde: StackOverflow
Rust tilbyder hastigheden af programmeringssprog på lavt niveau som C og C++ og sikkerheden ved programmeringssprog på højt niveau som Python.
Fra bemærkelsesværdige projekter som Dropbox og Firefox til WebAssembly og indlejret programmering, Rust er meget udbredt inden for alle områder af softwareudvikling. Rust tilbyder out-of-the-box support til pakkehåndtering gennem Cargo.
Cargo: Pakkechefen for Rust
Cargo er pakkeansvarlig for Rust. Du kan bruge last til at installere pakker fra kasser, Rust-pakkeregistret. Ud over at være en pakkehåndtering, der lader dig søge efter, installere og administrere pakker, fungerer cargo også som en testløber, en docs-generator og et byggesystem.
Nu hvor du har et overblik over Rust, så lad os se nærmere på nogle af de funktioner i Rust, der gør, at det skiller sig ud som et systemprogrammeringssprog med bred anvendelse.
Nyttige fejlmeddelelser
Som begynderprogrammør vil du løbe ind i fejl og bruge en betydelig mængde tid på at fejlsøge din kode. Du skal bruge fejlmeddelelserne og advarslerne fra compileren til at løse disse problemer. Og nyttige beskeder kan hjælpe dig med at fejlsøge hurtigere.
Eksempel på fejlmeddelelse
Når din kode ikke kompileres korrekt, giver Rust nyttige fejlmeddelelser, som giver forklaringer på, hvad der skal rettes i din kode, og hvor.
I dette eksempel er variablen num2 defineret inde i funktionen inner(). Det er derfor begrænset til funktionens omfang. Hvis du forsøger at få adgang til det uden for funktionen, kaster compileren en fejl:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Og fejlmeddelelsen giver info om, hvad der skal rettes.
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`
Advarsler under kompilering
Compileren giver også nyttige advarsler vedrørende problemer i din kode. Når du definerer variabler, men aldrig bruger dem i resten af programmet, giver Rust dig en advarselsmeddelelse, som vist.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Her er variablen num2 deklareret, men aldrig brugt.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Stærkt skrevet sprog
En anden grund til at du skal bruge Rust til dine udviklingsprojekter er dets typesystem. Rust er et stærkt maskinskrevet sprog, hvilket betyder, at det ikke understøtter typetvang. Typetvang er, når et sprog implicit kan konvertere en værdi i en datatype til en anden.
For eksempel vil Python-koden i den følgende kodecelle køre uden fejl. Dette skyldes, at i Python har et tal, der ikke er nul, sandhedsværdien True, og derfor kører if-sætningen uden fejl – selvom tallet 10 er et heltal – og ikke et boolesk tal.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
På den anden side tvinger Rust ikke typer. Så følgende kode vil give en fejl:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Fejlen rapporterer en type uoverensstemmelse, hvor en boolesk var forventet, og heltal blev fundet.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Hukommelsessikkerhed
Hukommelsessikkerhed er en anden funktion ved Rust, der gør den tiltalende for programmører. Vi vil forsøge at give et overblik over, hvordan dette fungerer.
Variabler skal initialiseres, før de tages i brug
I Rust skal alle variable initialiseres, før de kan bruges. I sprog som C vil følgende kode, hvor num ikke er initialiseret, kompilere og køre uden fejl. Værdien af den ikke-initialiserede variabel er en eller anden skraldværdi.
#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
Hvis du prøver at gøre noget lignende i Rust, vil du løbe ind i en kompileringsfejl. Rust har derfor ingen forestilling om affaldsindsamling.
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
|
Hukommelsessikkerhed på kompileringstidspunktet
Rust sikrer hukommelsessikkerhed på kompileringstidspunktet. Lad os tage et simpelt eksempel. Her, selvom den betingede if-sætning har en boolsk værdi på sand, hvilket betyder, at værdien af num altid vil være 100, får vi en fejl, når vi forsøger at udskrive værdien af num.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Dette skyldes, at betinget evaluering finder sted på kørselstidspunktet, og compileren vil ikke være i stand til at garantere, at num har en værdi på kompileringstidspunktet.
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
Hvis du ser nærmere på fejlmeddelelsen, vil du se, at vi med en else-sætning kan sikre, at num får en værdi. Så den følgende kode vil køre uden fejl. For på denne måde kan compileren bestemme, at num vil have en værdi – på kompileringstidspunktet – så der er ingen fejl.
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
Variables uforanderlighed
Det er også nyttigt at bemærke, at variabler i Rust er uforanderlige som standard. Det betyder, at du som udvikler ikke behøver at bekymre dig om ved et uheld at overskrive værdien af en bestemt variabel. Her er et eksempel:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Da num1 er initialiseret til 10, når du prøver at tildele den en værdi på 5, får du en fejlmeddelelse, der lyder ‘kan ikke tildele to gange til uforanderlig variabel 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
Ejerskab og låntagning
Ejerskab sikrer hukommelsessikkerhed. Funktionelt kan ejerskab i Rust opsummeres som følger:
Hver genstand bør have én og kun én ejer. Hvis ejeren går uden for rækkevidde, så tabes genstanden.
Lad os tage et simpelt eksempel. Her initialiserer vi en streng str1 og flytter derefter dens værdi til str2. Da ethvert objekt kun kan have én ejer, slettes str1-objektet, så snart dets værdi flyttes til 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
Selvom dette virker intuitivt, for bedre at forstå og værdsætte, hvordan ejerskab fungerer, er det nyttigt at lære begreberne lån og referencer.
Hurtig udvikling
Indtil videre har vi diskuteret flere nyttige funktioner i Rust-programmeringssproget. For at gennemgå et par stykker:
- Rust er optimeret til både hastighed og sikkerhed.
- Den leveres med et indbygget pakkehåndteringsværktøj og bygger et system.
- Det har også et rigt standardbibliotek.
I bund og grund tilbyder Rust alt, hvad en udvikler kan bede om. Derfor kan du med Rust udvikle applikationer hurtigt med minimal debugging og hurtigere builds.
Udvikling på tværs af platforme
Med Rust kan du vælge at udvikle på en platform efter eget valg. Rust understøtter de mest almindelige platforme: Linux, MacOS og Windows.
Applikationsudvikling er generelt let, da du kan kompilere Rust-kildekoden til en eksekverbar uden at være afhængig af andre byggeværktøjer og eksterne compilere.
Et støttende fællesskab går langt i at forenkle din læringsrejse. Rust har en enorm brugerbase, der kun vokser for hvert år, der går.
Populariteten af Rust i StackOverflow-udviklerundersøgelsen indikerer, at der er et stort fællesskab af brugere, med en masse erfarne udviklere, der er villige til at dele deres viden og ekspertise.
Udover den officielle dokumentation er der også et brugergenereret dokumentationssite og et diskussionsforum. Du kan også tjekke Rust subreddit- og LinkedIn-grupperne for relevante diskussioner.
Læringsressourcer til at komme i gang med rust
Dette afsnit viser nogle få nyttige ressourcer til at hjælpe dig i gang med Rust. Dette er ikke en udtømmende liste, men indeholder nogle anbefalede tutorials, kurser og bøger til at hjælpe dig på din læringsrejse.
#1. Rust ved eksempel
Rust By Example vil lære dig Rust fundamentals og standardbiblioteker gennem en række eksempler, som du kan kode sammen i en online editor.
De dækkede emner omfatter kasser, last: pakkehåndteringsværktøjet til Rust, generiske træk, egenskaber, fejlhåndtering og meget mere.
#2. Raslinger
Rustlings er en anden officiel læringsressource til Rust-programmeringssproget. Det ligner Rust ved eksempel. Det kræver dog, at du opsætter dit lokale udviklingsmiljø, kloner et eksempel på repo og løser simple problemer for at lære disse begreber.
#3. Træningsrustbane
Rustsporet om træning har mere end 100 øvelser, der hjælper dig med at lære og teste din forståelse af rust. Exercism er en gratis platform, hvor du kan blive vejledt af erfarne programmører udover at kode dig igennem øvelserne.
#4. Ultimativt Rust Crash Course
The Ultimate Rust Crash Course undervist af Nathan Stocks på Udemy dækker følgende:
- Fundamentals of Rust-programmering
- Modulsystem i Rust
- Datatyper og kontrolflow
- Reference og lån
- Strukturer, egenskaber og samlinger
#5. Ultimate Rust 2: Mellemkoncepter
Ultimate Rust 2 er et opfølgningskursus til Ultimate Rust Crash Course og dækker følgende emner:
- Lukninger
- Iteratorer
- Fejlhåndtering
- Enheds- og integrationstest
- Logning, multithreading og kanaler
#6. Rust lang: Den komplette begyndervejledning 2023
Dette Udemy-kursus undervist af Catalin Stefan er et omfattende kursus om Rust-programmering. Nogle af de behandlede emner inkluderer:
- Grundlæggende rust
- Datatyper, kontrolstrukturer
- Funktioner, træk
- Hukommelseshåndtering
- Samtidighed
#7. Programmering Rust: Hurtig, sikker systemudvikling
Programmering Rust af O’Reilly er en populær Rust-programmeringsbog, der vil lære dig følgende:
- Grundlæggende datatyper
- Ejerskab og låntagning
- Asynkron programmering
- Hurtige multithreading-applikationer
- Lukninger, iteratorer
- Samlinger
#8. The Rust Programming Language, 2. udgave
Rust-programmeringssproget er forfattet af kendte bidragydere fra Rust-samfundet. Denne bog dækker alt, hvad du behøver at vide om Rust, herunder:
- Ejerskab og låntagning
- Generiske, egenskaber
- Smarte pointer, multithreading
- Test og fejlhåndtering
#9. Den komplette rustprogrammeringsvejledning
Den komplette rustprogrammeringsvejledning fra Packt dækker følgende:
- Implementering af datastrukturer i Rust
- Skrive genbrugelige og testbare komponenter i Rust
- Design af multitrådede applikationer algoritme design og
- Anvendelser af Rust i WebAssembly, netværk og kommandolinjeapplikationer
#10. Kreative projekter for rustprogrammører
Hvis du er en erfaren udvikler, der lærer Rust, så vil det at bygge et par projekter i dit interessedomæne være tilstrækkeligt til at få et godt greb om sproget. Kreative projekter for rustprogrammører fra Packt er en bog, der lærer Rust ved at anvende dem på projekter som:
- Opbygning af afslappende webtjenester
- 2D-spil med
- Webapplikationsudvikling ved hjælp af WebAssembly
- Maskinsprogsemulatorer
- og mere!
Konklusion
Denne artikel præsenterede en oversigt over Rust som et systemprogrammeringssprog, herunder funktioner som hukommelsessikkerhed, forbedret pakkehåndtering og mere. Vi har også opregnet læringsressourcer for at hjælpe dig med at komme i gang med Rust.
Som et næste trin kan du vælge en eller flere af de nævnte læringsressourcer for at hente det grundlæggende i Rust. God Rust-programmering!
Du kan også udforske nogle af de bedste Rust-server-hostingudbydere.