Er du en utvikler som vurderer å fordype deg i Rust? Denne artikkelen vil introdusere deg for noen av de karakteristiske egenskapene til Rust, et programmeringsspråk som er stadig mer populært innen systemprogrammering, for å hjelpe deg med å ta en informert beslutning.
Vi skal se nærmere på Rusts programmeringsverden og undersøke funksjoner som typesystemet, minnesikkerhet og eierskapsmodellen. I tillegg vil vi gi deg en liste over ressurser som kan være nyttige for å lære Rust.
La oss sette i gang!
Hva kjennetegner Rust?
Rust er et programmeringsspråk spesielt designet for systemprogrammering. Det startet som et personlig initiativ av utvikleren Graydon Hoare i 2006. Siden den gang har det vokst i popularitet og er nå et foretrukket valg for systemprogrammering og beslektede applikasjoner. Gjennomsnittslønnen for en Rust-utvikler ligger på rundt $120 000.
Dersom du vurderer å bytte fra C++ til Rust, eller rett og slett ønsker å lære et nytt språk, kan Rust være et klokt valg! Ifølge en undersøkelse fra StackOverflow, har Rust blitt kåret til det mest elskede programmeringsspråket – hele syv år på rad.
Bildekilde: StackOverflow
Rust kombinerer hastigheten man finner i lavnivåspråk som C og C++, med sikkerheten til høynivåspråk som Python.
Fra velkjente prosjekter som Dropbox og Firefox, til WebAssembly og innebygd programmering, brukes Rust på en rekke områder innen programvareutvikling. Rust har også pakkehåndtering integrert gjennom Cargo.
Cargo: Pakkehåndtering for Rust
Cargo er Rust sitt standardverktøy for pakkehåndtering. Ved hjelp av Cargo kan du installere pakker fra kasser, som er Rusts egne pakke registre. Cargo er mer enn bare en pakkebehandler. Det gir deg også muligheten til å søke etter, installere og administrere pakker, i tillegg til å fungere som en testkjører, dokumentgenerator og et bygge system.
Nå som du har fått en oversikt over hva Rust er, la oss dykke dypere inn i noen av de karakteristiske egenskapene som gjør det til et unikt og populært systemprogrammeringsspråk.
Tydelige feilmeldinger
Som fersk programmerer er det naturlig å støte på feil, og det kan ta tid å feilsøke. Det er her kompilatorens feilmeldinger og advarsler kommer til nytte. Tydelige meldinger kan hjelpe deg med å identifisere og løse problemer raskere.
Eksempel på feilmelding
Når koden din ikke kompileres, gir Rust detaljerte feilmeldinger som forklarer nøyaktig hva som er feil og hvor feilen finnes.
I dette eksemplet er variabelen num2 definert i funksjonen inner(). Dette betyr at den kun er tilgjengelig innenfor funksjonens virkeområde. Hvis du forsøker å bruke den utenfor funksjonen, vil kompilatoren gi en feilmelding:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("Verdien av num2 er: {}", num2);
}
Feilmeldingen indikerer hva som må korrigeres.
error[E0425]: finner ikke verdien `num2` i dette omfanget
--> src/main.rs:6:42
|
6 | println!("Verdien av num2 er: {}", num2);
| ^^^^ hjelp: en lokal variabel med lignende navn finnes: `num1`
Advarsler under kompilering
Kompilatoren gir også nyttige advarsler knyttet til potensielle problemer i koden din. Hvis du definerer en variabel, men aldri bruker den, vil Rust gi deg en advarsel, som vist under.
fn main() {
let num1 = 10;
let num2 = 9;
println!("Verdien av num1 er: {}", num1);
}
Her er variabelen num2 deklarert, men aldri brukt.
advarsel: ubrukt variabel: `num2`
--> src/main.rs:3:9
|
3 | let num2 = 9;
| ^^^^ hjelp: hvis dette er tilsiktet, legg til et understrek foran: `_num2`
|
Sterkt typet språk
En annen fordel med å velge Rust for dine utviklingsprosjekter, er typesystemet. Rust er et sterkt typet språk, noe som betyr at det ikke tillater typekonvertering uten eksplisitt angivelse. Typekonvertering oppstår når et språk automatisk konverterer en verdi fra en datatype til en annen.
For eksempel vil Python-koden i koden nedenfor kjøre uten feil. Dette er fordi i Python vil et tall som ikke er null ha sannhetsverdien True, og if-setningen vil kjøre uten problemer – selv om tallet 10 er et heltall og ikke en boolsk verdi.
num1 = 10
if num1:
num2 = 9
print(f"num2 er {num2}")
# Output: num2 er 9
Rust derimot, tvinger ikke frem typekonverteringer. Følgende kode vil derfor generere en feil:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Feilmeldingen rapporterer en typekonflikt, der en boolsk verdi var forventet, men et heltall ble funnet.
error[E0308]: uoverensstemmende typer
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ forventet `bool`, fant heltall
Minnesikkerhet
Minnesikkerhet er en annen egenskap ved Rust som gjør det attraktivt for utviklere. Vi skal forsøke å gi en oversikt over hvordan dette fungerer.
Variabler må initialiseres før bruk
I Rust må alle variabler ha en verdi før de kan brukes. I språk som C vil følgende kode, der num ikke er initialisert, kompilere og kjøre uten feil. Verdien av den uinitialiserte variabelen vil da være en tilfeldig «søppel»-verdi.
#include <stdio.h>
int main(void) {
int num;
printf("Verdien av num er %d", num);
return 0;
}
// Output: Verdien av num er 0
Hvis du forsøker å gjøre noe lignende i Rust, vil du få en kompileringsfeil. Rust har ingen form for automatisk søppeltømming.
fn main() {
let num:i32;
println!("Verdien av num er: {}",num);
}
error[E0381]: brukt binding `num` er ikke initialisert
--> src/main.rs:3:40
|
2 | let num:i32;
| --- binding deklarert her, men ikke initialisert
3 | println!("Verdien av num er: {}",num);
| ^^^ `num` brukt her, men den er ikke initialisert
|
Minnesikkerhet ved kompilering
Rust garanterer minnesikkerhet allerede ved kompilering. La oss se på et enkelt eksempel. Her vil feilkoden oppstå dersom vi prøver å skrive ut verdien av num. Dette skjer selv om if-setningen har en sann verdi, som betyr at num alltid vil ha verdien 100.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("Verdien av num er: {}", num);
}
Dette er fordi betinget evaluering skjer under kjøring, og kompilatoren kan ikke garantere at num har en verdi på kompileringstidspunktet.
error[E0381]: brukt binding `num` er muligens ikke-initialisert
--> src/main.rs:6:41
|
2 | let num:i32;
| --- binding deklarert her, men ikke initialisert
3 | if true{
| ---- hvis `if`-betingelsen er `false`, blir ikke `num` initialisert
4 | num = 100;
5 | }
| - en `else`-gren mangler kanskje, for å initialisere `num`
6 | println!("Verdien av num er: {}", num);
| ^^^ `num` brukt her, men er muligens ikke-initialisert
Hvis du ser nærmere på feilmeldingen, vil du se at en else-setning kan sikre at num alltid har en verdi. Dermed vil koden under kjøre uten feil. På denne måten kan kompilatoren slå fast at num vil ha en verdi – på kompileringstidspunktet – og ingen feil oppstår.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("Verdien av num er: {}", num);
}
Verdien av num er: 100
Uforanderlighet av variabler
Det er også verdt å merke seg at variabler i Rust er uforanderlige som standard. Dette betyr at som utvikler trenger du ikke å bekymre deg for å overskrive verdien til en variabel ved et uhell. Her er et eksempel:
fn main() {
let num1 = 10;
num1 = 5;
println!("Verdien av num1 er: {}", num1);
}
Siden num1 er initialisert med 10, vil du motta en feilmelding som sier «kan ikke tilordne to ganger til uforanderlig variabel num1» når du prøver å gi den verdien 5.
error[E0384]: kan ikke tilordne to ganger til uforanderlig variabel `num1`
--> src/main.rs:3:5
|
2 | let num1 = 10;
| ----
| |
| første tilordning til `num1`
| hjelp: vurder å gjøre denne bindingen foranderlig: `mut num1`
3 | num1 = 5;
| ^^^^^^^^ kan ikke tilordne to ganger til uforanderlig variabel
Eierskap og låneopptak
Eierskap sikrer minnesikkerhet. Funksjonelt sett kan eierskap i Rust oppsummeres slik:
Hvert objekt skal ha en og bare en eier. Når eieren går utenfor virkeområdet, blir objektet slettet.
La oss se på et enkelt eksempel. Her initialiserer vi en streng str1 og flytter deretter verdien til str2. Siden et objekt kun kan ha en eier, blir str1 slettet så snart verdien flyttes til str2.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("Verdien av str1 er: {}", str1);
}
error[E0382]: lån av flyttet verdi: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- flytting skjer fordi `str1` har typen `String`, som ikke implementerer `Copy`-egenskapen
3 | let str2 = str1;
| ---- verdi flyttet hit
4 | println!("Verdien av str1 er: {}", str1);
| ^^^^ verdi lånt her etter flytting
Selv om dette kan virke ulogisk ved første øyekast, er det viktig å lære seg konseptene lån og referanser for å forstå hvordan eierskap fungerer i praksis.
Rask utvikling
Vi har hittil diskutert flere nyttige egenskaper ved Rust. La oss oppsummere noen av de viktigste:
- Rust er optimalisert for både hastighet og sikkerhet.
- Det kommer med et integrert pakkehåndteringsverktøy og byggesystem.
- Det har også et omfattende standardbibliotek.
Kort sagt, Rust tilbyr alt en utvikler kan ønske seg. Derfor kan du utvikle applikasjoner raskt, med minimal feilsøking og kortere byggetid.
Utvikling på tvers av plattformer
Med Rust kan du velge å utvikle på den plattformen du foretrekker. Rust støtter de mest brukte plattformene: Linux, MacOS og Windows.
Applikasjonsutvikling er generelt enkelt, ettersom du kan kompilere Rust-kildekoden til en kjørbar fil uten å være avhengig av andre byggeverktøy eller eksterne kompilatorer.
Et aktivt og hjelpsomt fellesskap er viktig for å gjøre læringsprosessen enklere. Rust har en stor brukerbase som bare vokser for hvert år.
Rusts popularitet i StackOverflows utviklerundersøkelse indikerer at det finnes et stort fellesskap av brukere, med mange erfarne utviklere som er villige til å dele sin kunnskap og erfaring.
I tillegg til den offisielle dokumentasjonen, finnes det også en brukergenerert dokumentasjonsside og et diskusjonsforum. Du kan også sjekke Rusts subreddit- og LinkedIn-grupper for relevante diskusjoner.
Læringsressurser for å komme i gang med Rust
Denne delen viser noen nyttige ressurser som kan hjelpe deg i gang med Rust. Dette er ikke en fullstendig liste, men den inneholder noen anbefalte veiledninger, kurs og bøker som kan være nyttige i læringsprosessen.
#1. Rust ved eksempel
Rust By Example lærer deg det grunnleggende om Rust og standardbibliotekene gjennom en rekke eksempler som du kan kode sammen i en nettbasert editor.
Temaene som dekkes inkluderer kasser, Cargo (pakkehåndteringsverktøyet for Rust), generiske egenskaper, feilhåndtering og mye mer.
#2. Rustlings
Rustlings er en annen offisiell læringsressurs for programmeringsspråket Rust. Den ligner på Rust ved eksempel. Det krever imidlertid at du setter opp ditt eget lokale utviklingsmiljø, kloner en eksempel-repo og løser enkle problemer for å lære disse konseptene.
#3. Treningsrustbane
Rust Track på Exercism har over 100 oppgaver som hjelper deg å lære og teste din forståelse av Rust. Exercism er en gratis plattform der du kan få veiledning fra erfarne programmerere i tillegg til å kode deg gjennom oppgavene.
#4. Ultimate Rust Crash Course
Ultimate Rust Crash Course, undervist av Nathan Stocks på Udemy, dekker følgende temaer:
- Grunnleggende om Rust-programmering
- Modulsystemet i Rust
- Datatyper og kontrollflyt
- Referanser og låneopptak
- Strukturer, egenskaper og samlinger
#5. Ultimate Rust 2: Mellomkonsepter
Ultimate Rust 2 er et oppfølgingskurs til Ultimate Rust Crash Course og dekker disse emnene:
- Nedleggelser
- Iteratorer
- Feilhåndtering
- Enhets- og integrasjonstesting
- Loggføring, multithreading og kanaler
#6. Rust lang: Den komplette nybegynnerguiden 2023
Dette Udemy-kurset, undervist av Catalin Stefan, er et omfattende kurs om Rust-programmering. Noen av temaene som dekkes er:
- Grunnleggende om Rust
- Datatyper og kontrollstrukturer
- Funksjoner og egenskaper
- Minnehåndtering
- Samtidighet
#7. Programmering Rust: Rask, sikker systemutvikling
Programmering Rust av O’Reilly er en populær bok om Rust-programmering som lærer deg følgende:
- Grunnleggende datatyper
- Eierskap og låneopptak
- Asynkron programmering
- Raske multithreading-applikasjoner
- Nedleggelser og iteratorer
- Samlinger
#8. Rust-programmeringsspråket, 2. utgave
Rust-programmeringsspråket er skrevet av anerkjente bidragsytere fra Rust-fellesskapet. Denne boken dekker alt du trenger å vite om Rust, inkludert:
- Eierskap og låneopptak
- Generiske egenskaper
- Smarte pekere og multithreading
- Testing og feilhåndtering
#9. Den komplette referanseveiledningen for Rust-programmering
Den komplette referanseveiledningen for Rust-programmering fra Packt dekker følgende:
- Implementering av datastrukturer i Rust
- Skriving av gjenbrukbare og testbare komponenter i Rust
- Design av multithreaded applikasjoner, algoritmedesign og
- Bruk av Rust i WebAssembly, nettverk og kommandolinjeapplikasjoner
#10. Kreative prosjekter for Rust-programmerere
Hvis du er en erfaren utvikler som lærer Rust, kan det være nok å bygge noen få prosjekter i dine interesseområder for å få et godt grep om språket. Creative Projects for Rust Programmers fra Packt er en bok som lærer deg Rust ved å bruke språket på prosjekter som:
- Bygging av avslappende webtjenester
- 2D-spill med
- Utvikling av webapplikasjoner ved hjelp av WebAssembly
- Maskinspråksemulatorer
- Og mye mer!
Konklusjon
Denne artikkelen har gitt deg en oversikt over Rust som et systemprogrammeringsspråk, inkludert egenskaper som minnesikkerhet, forbedret pakkehåndtering og mer. Vi har også listet opp ressurser som kan hjelpe deg med å komme i gang med Rust.
Som et neste steg kan du velge en eller flere av de nevnte læringsressursene for å lære det grunnleggende om Rust. Lykke til med Rust-programmeringen!
Du kan også utforske noen av de beste leverandørene for Rust-servere.