Är du en utvecklare som vill lära dig Rust? För att hjälpa dig att bestämma, presenterar den här artikeln några av funktionerna i Rust, ett av de mest populära systemprogrammeringsspråken.
I den här artikeln kommer vi att utforska programmeringsspråket Rust och dess funktioner, såsom typsystem, minnessäkerhet och ägande. Vi kommer också att gå igenom en lista med resurser som kan hjälpa dig att lära dig Rust.
Låt oss börja!
Innehållsförteckning
Vad är rost?
Rust är ett systemprogrammeringsspråk. Det började som ett personligt projekt av Graydon Hoare, en utvecklare, redan 2006. På mindre än ett decennium har det vuxit till att bli det bästa valet för systemprogrammering och liknande applikationer. Medellönen för en Rust-programmerare är cirka 120 000 USD.
Så om du funderar på att byta från C++ till Rust eller letar efter ett nytt språk, kan lära sig Rust vara ett utmärkt val! Enligt StackOverflow Developer-undersökningen har Rust röstats fram som det mest älskade programmeringsspråket – i sju år i rad.
Bildkälla: StackOverflow
Rust erbjuder hastigheten för programmeringsspråk för lågnivåsystem som C och C++ och säkerheten hos högnivåprogrammeringsspråk som Python.
Från anmärkningsvärda projekt som Dropbox och Firefox till WebAssembly och inbäddad programmering, Rust används flitigt inom alla områden av mjukvaruutveckling. Rust erbjuder pakethanteringsstöd direkt genom Cargo.
Cargo: Pakethanteraren för Rust
Cargo är paketansvarig för Rust. Du kan använda last för att installera paket från lådor, Rust-paketregistret. Förutom att vara en pakethanterare som låter dig söka efter, installera och hantera paket, fungerar cargo också som en testkörare, en dokumentgenerator och ett byggsystem.
Nu när du har en överblick över Rust, låt oss ta en närmare titt på några av funktionerna i Rust som gör att det sticker ut som ett systemprogrammeringsspråk med bred användning.
Användbara felmeddelanden
Som nybörjarprogrammerare kommer du att stöta på fel och spendera en betydande tid på att felsöka din kod. Du kommer att använda felmeddelandena och varningarna från kompilatorn för att åtgärda dessa problem. Och användbara meddelanden kan hjälpa dig att felsöka snabbare.
Ett exempel på felmeddelande
När din kod inte kompileras framgångsrikt, ger Rust användbara felmeddelanden som ger förklaringar av vad som behöver fixas i din kod och var.
I det här exemplet är variabeln num2 definierad i funktionen inner(). Den är därför begränsad till funktionens omfattning. Om du försöker komma åt den utanför funktionen, ger kompilatorn ett felmeddelande:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Och felmeddelandet ger information om vad som behöver åtgärdas.
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`
Varningar under kompilering
Kompilatorn ger också användbara varningar angående problem i din kod. När du definierar variabler men aldrig använder dem i resten av programmet, ger Rust dig ett varningsmeddelande, som visas.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Här deklareras variabeln num2 men används aldrig.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Starkt typspråk
En annan anledning till att du bör använda Rust för dina utvecklingsprojekt är dess typsystem. Rust är ett starkt maskinskrivet språk, vilket betyder att det inte stöder typtvång. Typtvång är när ett språk implicit kan konvertera ett värde i en datatyp till en annan.
Till exempel kommer Python-koden i följande kodcell att köras utan fel. Detta beror på att i Python har ett tal som inte är noll sanningsvärdet True, och därför kör if-satsen utan fel – även om talet 10 är ett heltal – och inte ett booleskt tal.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
Å andra sidan tvingar Rust inte typer. Så följande kod kommer att ge ett fel:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Felet rapporterar en typfel, där ett booleskt tal förväntades och heltal hittades.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Minnessäkerhet
Minnessäkerhet är en annan funktion hos Rust som gör den tilltalande för programmerare. Vi ska försöka ge en översiktlig översikt över hur detta fungerar.
Variabler måste initieras innan de används
I Rust måste alla variabler initieras innan de kan användas. I språk som C kommer följande kod där num inte är initialiserat att kompilera och köras utan fel. Värdet på den oinitierade variabeln är ett skräpvärde.
#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
Om du försöker göra något liknande i Rust kommer du att stöta på ett kompileringsfel. Rust har därför ingen aning om sophämtning.
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
|
Minnessäkerhet vid kompileringstid
Rust säkerställer minnessäkerhet vid kompilering. Låt oss ta ett enkelt exempel. Här, även om villkorssatsen if har ett booleskt värde på sant, vilket betyder att värdet på num alltid kommer att vara 100, får vi ett felmeddelande när vi försöker skriva ut värdet på num.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Detta beror på att villkorlig utvärdering sker vid körning och kompilatorn kommer inte att kunna garantera att num har ett värde vid kompilering.
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
Om du tittar närmare på felmeddelandet ser du att med en else-sats kan vi säkerställa att num kommer att ha ett värde. Så följande kod kommer att köras utan fel. Eftersom på detta sätt kan kompilatorn bestämma att num kommer att ha ett värde – vid kompileringstid – så det finns inga fel.
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
Variablers oföränderlighet
Det är också bra att notera att variabler i Rust är oföränderliga som standard. Detta innebär att du som utvecklare inte behöver oroa dig för att av misstag skriva över värdet på en viss variabel. Här är ett exempel:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Eftersom num1 initieras till 10, när du försöker tilldela det ett värde på 5, får du ett felmeddelande som lyder ”kan inte tilldela två gånger till oföränderlig 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
Ägande och upplåning
Ägarskap säkerställer minnessäkerhet. Funktionellt kan ägandet i Rust sammanfattas på följande sätt:
Varje objekt bör ha en och endast en ägare. Om ägaren går utanför räckvidden släpps objektet.
Låt oss ta ett enkelt exempel. Här initierar vi en sträng str1 och flyttar sedan dess värde till str2. Eftersom alla objekt bara kan ha en ägare, tas str1-objektet bort så snart dess värde flyttas till 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
Även om detta verkar intuitivt, för att bättre förstå och uppskatta hur ägande fungerar, är det bra att lära sig begreppen lån och referenser.
Snabb utveckling
Hittills har vi diskuterat flera användbara funktioner i programmeringsspråket Rust. För att recensera några:
- Rost är optimerad för både hastighet och säkerhet.
- Den kommer med ett inbyggt pakethanteringsverktyg och bygger ett system.
- Den har också ett rikt standardbibliotek.
I grund och botten erbjuder Rust allt en utvecklare kan begära. Därför kan du med Rust utveckla applikationer snabbt med minimal felsökning och snabbare konstruktioner.
Plattformsöverskridande utveckling
Med Rust kan du välja att utveckla på en plattform du väljer. Rust stöder de vanligaste plattformarna: Linux, MacOS och Windows.
Applikationsutveckling är i allmänhet lätt eftersom du kan kompilera Rust-källkoden till en körbar fil utan att vara beroende av andra byggverktyg och externa kompilatorer.
En stödjande gemenskap gör en lång väg för att förenkla din inlärningsresa. Rust har en enorm användarbas som bara växer för varje år som går.
Populariteten för Rust i StackOverflow-utvecklarundersökningen indikerar att det finns en stor gemenskap av användare, med många erfarna utvecklare som är villiga att dela med sig av sin kunskap och expertis.
Utöver den officiella dokumentationen finns det även en användargenererad dokumentationssida och ett diskussionsforum. Du kan också kontrollera Rust subreddit- och LinkedIn-grupperna för relevanta diskussioner.
Lärresurser för att komma igång med rost
Det här avsnittet listar några användbara resurser som hjälper dig att komma igång med Rust. Det här är inte en uttömmande lista men innehåller några rekommenderade handledningar, kurser och böcker som hjälper dig på din inlärningsresa.
#1. Rost till exempel
Rust By Example kommer att lära dig Rust grunder och standardbibliotek genom en serie exempel som du kan koda med i en onlineredigerare.
Ämnena som behandlas inkluderar lådor, last: pakethanteringsverktyget för Rust, generika, egenskaper, felhantering och mycket mer.
#2. Prasslar
Rustlings är en annan officiell inlärningsresurs för programmeringsspråket Rust. Det liknar Rust till exempel. Det kräver dock att du ställer in din lokala utvecklingsmiljö, klona en exempelrepo och löser enkla problem för att lära dig dessa begrepp.
#3. Övningsrostbana
The Rust Track on Exercism har mer än 100 övningar som hjälper dig att lära dig och testa din förståelse av Rust. Exercism är en gratis plattform där du kan få mentor av erfarna programmerare förutom att koda dig igenom övningarna.
#4. Ultimate Rust Crash Course
The Ultimate Rust Crash Course som Nathan Stocks undervisar på Udemy täcker följande:
- Grunderna i Rust-programmering
- Modulsystem i Rust
- Datatyper och kontrollflöde
- Referens och upplåning
- Strukturer, egenskaper och samlingar
#5. Ultimate Rust 2: Intermediate Concepts
Ultimate Rust 2 är en uppföljningskurs till Ultimate Rust Crash Course och täcker följande ämnen:
- Stängningar
- Iteratorer
- Felhantering
- Enhets- och integrationstest
- Loggning, multithreading och kanaler
#6. Rust lang: Den kompletta nybörjarguiden 2023
Denna Udemy-kurs som undervisas av Catalin Stefan är en omfattande kurs i Rust-programmering. Några av de ämnen som tas upp inkluderar:
- Grundläggande rost
- Datatyper, kontrollstrukturer
- Funktioner, egenskaper
- Minneshantering
- Samtidighet
#7. Programmering Rust: Snabb, säker systemutveckling
Programmering Rust av O’Reilly är en populär Rust-programmeringsbok som lär dig följande:
- Grundläggande datatyper
- Ägande och upplåning
- Asynkron programmering
- Snabba flertrådsapplikationer
- Stängningar, iteratorer
- Samlingar
#8. The Rust Programming Language, 2:a upplagan
Rust-programmeringsspråket är författat av kända bidragsgivare från Rust-gemenskapen. Den här boken täcker allt du behöver veta om Rust, inklusive:
- Ägande och upplåning
- Generika, egenskaper
- Smarta pekare, multithreading
- Testning och felhantering
#9. Den kompletta rostprogrammeringsreferensguiden
Den kompletta rostprogrammeringsreferensguiden från Packt täcker följande:
- Implementering av datastrukturer i Rust
- Skriver återanvändbara och testbara komponenter i Rust
- Designa flertrådade applikationer algoritmdesign och
- Tillämpningar av Rust i WebAssembly, nätverk och kommandoradsapplikationer
#10. Kreativa projekt för rostprogrammerare
Om du är en erfaren utvecklare som lär dig Rust, räcker det med att bygga några projekt inom din intressedomän för att få ett bra grepp om språket. Creative Projects for Rust Programmers från Packt är en bok som lär ut Rust genom att tillämpa dem på projekt som:
- Bygga vilsamma webbtjänster
- 2D-spel med
- Webbapplikationsutveckling med hjälp av WebAssembly
- Maskinspråksemulatorer
- och mer!
Slutsats
Den här artikeln presenterade en översikt över Rust som ett systemprogrammeringsspråk, inklusive funktioner som minnessäkerhet, förbättrad pakethantering och mer. Vi räknade också upp lärresurser för att hjälpa dig komma igång med Rust.
Som nästa steg kan du välja en eller flera av lärresurserna som nämns för att hämta grunderna i Rust. Glad Rust-programmering!
Du kan också utforska några av de bästa leverantörerna av Rust-servervärdar.