Er du en utvikler som ønsker å lære Rust? For å hjelpe deg med å bestemme, presenterer denne artikkelen noen av funksjonene til Rust, et av de mest populære systemprogrammeringsspråkene.
I denne artikkelen skal vi utforske Rust-programmeringsspråket og dets funksjoner, for eksempel typesystem, minnesikkerhet og eierskap. Vi vil også gå over en liste over ressurser som kan hjelpe deg å lære Rust.
La oss begynne!
Innholdsfortegnelse
Hva er rust?
Rust er et systemprogrammeringsspråk. Det startet som et personlig prosjekt av Graydon Hoare, en utvikler, tilbake i 2006. På mindre enn et tiår har det vokst til å bli det foretrukne valget for systemprogrammering og beslektede applikasjoner. Gjennomsnittslønnen til en Rust-programmerer er rundt $120K.
Så hvis du ønsker å bytte fra C++ til Rust eller ønsker å velge et nytt språk, kan det å lære Rust være et godt valg! I følge StackOverflow Developer-undersøkelsen har Rust blitt kåret til det mest elskede programmeringsspråket – i syv år på rad.
Bildekilde: StackOverflow
Rust tilbyr hastigheten til programmeringsspråk på lavt nivå som C og C++ og sikkerheten til programmeringsspråk på høyt nivå som Python.
Fra bemerkelsesverdige prosjekter som Dropbox og Firefox til WebAssembly og innebygd programmering, Rust er mye brukt i alle områder av programvareutvikling. Rust tilbyr pakkehåndteringsstøtte direkte gjennom Cargo.
Last: Pakkesjefen for Rust
Cargo er pakkeansvarlig for Rust. Du kan bruke last til å installere pakker fra kasser, Rust-pakkeregisteret. I tillegg til å være en pakkebehandling som lar deg søke etter, installere og administrere pakker, fungerer cargo også som en testløper, en dokumentgenerator og et byggesystem.
Nå som du har en oversikt over Rust, la oss se nærmere på noen av funksjonene til Rust som gjør at det skiller seg ut som et systemprogrammeringsspråk med bred bruk.
Nyttige feilmeldinger
Som nybegynnerprogrammerer vil du støte på feil og bruke betydelig tid på å feilsøke koden din. Du vil bruke feilmeldingene og advarslene fra kompilatoren for å fikse disse problemene. Og nyttige meldinger kan hjelpe deg med å feilsøke raskere.
Eksempel på feilmelding
Når koden din ikke kompileres vellykket, gir Rust nyttige feilmeldinger som gir forklaringer på hva som må fikses i koden og hvor.
I dette eksemplet er variabelen num2 definert inne i funksjonen inner(). Den er derfor begrenset til funksjonens omfang. Hvis du prøver å få tilgang til den utenfor funksjonen, gir kompilatoren en feilmelding:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Og feilmeldingen gir info om hva som må fikses.
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
Kompilatoren gir også nyttige advarsler angående problemer i koden din. Når du definerer variabler, men aldri bruker dem i resten av programmet, gir Rust deg en advarsel, som vist.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Her er variabelen num2 deklarert, men aldri brukt.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Sterkt skrevet språk
En annen grunn til at du bør bruke Rust for utviklingsprosjektene dine, er typesystemet. Rust er et sterkt maskinskrevet språk, noe som betyr at det ikke støtter typetvang. Typetvang er når et språk implisitt kan konvertere en verdi i en datatype til en annen.
For eksempel vil Python-koden i følgende kodecelle kjøre uten feil. Dette er fordi i Python har et tall som ikke er null sannhetsverdien True, og derfor kjører if-setningen uten feil – selv om tallet 10 er et heltall – og ikke en boolsk.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
På den annen side tvinger ikke Rust typer. Så følgende kode vil gi en feil:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Feilen rapporterer en type uoverensstemmelse, der en boolsk var forventet og heltall ble funnet.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Minnesikkerhet
Minnesikkerhet er en annen funksjon ved Rust som gjør den attraktiv for programmerere. Vi skal prøve å gi en oversiktlig oversikt over hvordan dette fungerer.
Variabler må initialiseres før de tas i bruk
I Rust må alle variabler initialiseres 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 til den uinitialiserte variabelen er en søppelverdi.
#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 å gjøre noe lignende i Rust, får du en kompileringsfeil. Rust har derfor ingen forestilling om søppelinnsamling.
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
|
Minnesikkerhet ved kompilering
Rust sikrer minnesikkerhet ved kompilering. La oss ta et enkelt eksempel. Her, selv om den betingede setningen if har en boolsk verdi på sann, som betyr at verdien av num alltid vil være 100, får vi en feilmelding når vi prøver å skrive ut verdien av num.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Dette er fordi betinget evaluering skjer ved kjøretid, og kompilatoren vil ikke kunne garantere at num har en verdi 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å feilmeldingen, vil du se at med en else-setning kan vi sikre at num vil ha en verdi. Så følgende kode vil kjøre uten feil. Fordi på denne måten kan kompilatoren bestemme at num vil ha en verdi – på kompileringstidspunktet – så det er ingen feil.
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
Uforanderlighet av variabler
Det er også nyttig å merke seg at variabler i Rust er uforanderlige som standard. Dette betyr at du som utvikler ikke trenger å bekymre deg for å overskrive verdien til en bestemt variabel ved et uhell. Her er et eksempel:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Ettersom num1 er initialisert til 10, når du prøver å tilordne den en verdi på 5, får du en feilmelding som lyder «kan ikke tilordne to ganger 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
Eierskap og låneopptak
Eierskap sikrer minnesikkerhet. Funksjonelt kan eierskap i Rust oppsummeres slik:
Hvert objekt skal ha én og bare én eier. Hvis eieren går utenfor rekkevidde, blir objektet droppet.
La oss ta et enkelt eksempel. Her initialiserer vi en streng str1 og flytter deretter verdien til str2. Siden ethvert objekt bare kan ha én eier, blir str1-objektet droppet så snart verdien 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
Selv om dette virker intuitivt, for bedre å forstå og verdsette hvordan eierskap fungerer, er det nyttig å lære begrepene lån og referanser.
Rask utvikling
Så langt har vi diskutert flere nyttige funksjoner i Rust-programmeringsspråket. For å gjennomgå noen:
- Rust er optimalisert for både hastighet og sikkerhet.
- Den kommer med et innebygd pakkehåndteringsverktøy og bygger et system.
- Den har også et rikt standardbibliotek.
I hovedsak tilbyr Rust alt en utvikler kan be om. Derfor, med Rust, kan du utvikle applikasjoner raskt med minimal feilsøking og raskere bygg.
Utvikling på tvers av plattformer
Med Rust kan du velge å utvikle på en plattform du ønsker. Rust støtter de vanligste 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 og eksterne kompilatorer.
Et støttende fellesskap gjør mye for å forenkle læringsreisen din. Rust har en enorm brukerbase som bare vokser for hvert år som går.
Populariteten til Rust i StackOverflow-utviklerundersøkelsen indikerer at det er et stort fellesskap av brukere, med mange erfarne utviklere som er villige til å dele sin kunnskap og ekspertise.
I tillegg til den offisielle dokumentasjonen finnes det også en brukergenerert dokumentasjonsside og et diskusjonsforum. Du kan også sjekke Rust subreddit- og LinkedIn-gruppene for relevante diskusjoner.
Læringsressurser for å komme i gang med rust
Denne delen viser noen nyttige ressurser for å hjelpe deg med å komme i gang med Rust. Dette er ikke en uttømmende liste, men inkluderer noen anbefalte opplæringsprogrammer, kurs og bøker for å hjelpe deg i læringsreisen.
#1. Rust ved eksempel
Rust By Example vil lære deg Rust-grunnleggende og standardbiblioteker gjennom en rekke eksempler som du kan kode sammen i en online editor.
Emnene som dekkes inkluderer kasser, last: pakkehåndteringsverktøyet for Rust, generiske egenskaper, egenskaper, feilhåndtering og mye mer.
#2. Raslinger
Rustlings er en annen offisiell læringsressurs for programmeringsspråket Rust. Det ligner på Rust ved eksempel. Det krever imidlertid at du setter opp ditt lokale utviklingsmiljø, kloner et eksempel på repo og løser enkle problemer for å lære disse konseptene.
#3. Treningsrustbane
The Rust Track on Exercism har mer enn 100 øvelser for å hjelpe deg å lære og teste din forståelse av Rust. Exercism er en gratis plattform hvor du kan få veiledning av erfarne programmerere i tillegg til å kode deg gjennom øvelsene.
#4. Ultimate Rust Crash Course
The Ultimate Rust Crash Course undervist av Nathan Stocks på Udemy dekker følgende:
- Grunnleggende om Rust-programmering
- Modulsystem i Rust
- Datatyper og kontrollflyt
- Referanse og lån
- Strukturer, egenskaper og samlinger
#5. Ultimate Rust 2: Mellomkonsepter
Ultimate Rust 2 er et oppfølgingskurs til Ultimate Rust Crash Course og dekker følgende emner:
- Nedleggelser
- Iteratorer
- Feilhåndtering
- Enhets- og integrasjonstest
- Logging, 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 inkluderer:
- Grunnleggende om rust
- Datatyper, kontrollstrukturer
- Funksjoner, egenskaper
- Minnehåndtering
- Samtidighet
#7. Programmering Rust: Rask, sikker systemutvikling
Programmering Rust av O’Reilly er en populær Rust-programmeringsbok som vil lære deg følgende:
- Grunnleggende datatyper
- Eierskap og låneopptak
- Asynkron programmering
- Raske multithreading-applikasjoner
- Nedleggelser, iteratorer
- Samlinger
#8. The Rust Programming Language, 2. utgave
Rust-programmeringsspråket er skrevet av anerkjente bidragsytere fra Rust-samfunnet. Denne boken dekker alt du trenger å vite om Rust, inkludert:
- Eierskap og låneopptak
- Generiske, egenskaper
- Smarte tips, multithreading
- Testing og feilhåndtering
#9. Den komplette referanseveiledningen for rustprogrammering
Den komplette referanseveiledningen for rustprogrammering fra Packt dekker følgende:
- Implementering av datastrukturer i Rust
- Skrive gjenbrukbare og testbare komponenter i Rust
- Designe multithreaded applikasjoner algoritme design og
- Applikasjoner av Rust i WebAssembly, nettverk og kommandolinjeapplikasjoner
#10. Kreative prosjekter for rustprogrammerere
Hvis du er en erfaren utvikler som lærer Rust, vil det være nok å bygge noen få prosjekter i ditt interessedomene for å få et godt grep om språket. Creative Projects for Rust Programmers fra Packt er en bok som lærer Rust ved å bruke dem på prosjekter som:
- Bygge avslappende webtjenester
- 2D-spill med
- Webapplikasjonsutvikling ved hjelp av WebAssembly
- Maskinspråkemulatorer
- og mer!
Konklusjon
Denne artikkelen presenterte en oversikt over Rust som et systemprogrammeringsspråk, inkludert funksjoner som minnesikkerhet, forbedret pakkehåndtering og mer. Vi har også oppregnet læringsressurser for å hjelpe deg med å komme i gang med Rust.
Som et neste trinn kan du velge en eller flere av læringsressursene som er nevnt for å finne det grunnleggende om Rust. God Rust-programmering!
Du kan også utforske noen av de beste vertsleverandørene for Rust-servere.