Alt hvad du behøver at vide for at begynde at skrive rust

Siden udgivelsen i 2015 har Rust vundet popularitet som et af udviklernes foretrukne programmeringssprog. Rust tilbyder fremragende ydeevne og sikkerhedsfunktioner med intuitiv og kortfattet syntaks, der gør sproget ønskværdigt.

Rust er velegnet til at bygge forskellige programmer, herunder webapps, kommandolinjeværktøjer og netværkstjenester. Rust indeholder mange funktioner, du kan forvente af et moderne programmeringssprog, såsom samtidighed, typeslutning og mere.

Kom godt i gang med rust

Rust er et programmeringssprog på tværs af platforme, der kører på de fleste operativsystemer. Gå til embedsmanden for at komme i gang med Rust Rust hjemmeside og installer den foretrukne version til dit operativsystem.

Når du har installeret Rust, kan du begynde at skrive programmer i Rust-filer med en .rs udvidelse. Rust er alsidig og nem at lære. Du vil finde det ligetil, hvis du har tidligere erfaring med programmering.

Variabler og konstanter i rust

Rust er meget udtryksfuldt, og der er flere måder at erklære variable på. Du kan bruge lade nøgleord til at erklære variabler.

Sådan kan du erklære variabler i Rust:

lade en: Snor;
lade b: i32;
lade c: () = ();

Det -en og b variabler er henholdsvis en streng og et heltal. Det c variabel er en Rust-enhedstype, der fungerer som en pladsholder for funktioner og udtryk.

Efter den valgfrie datatypeerklæring kan du deklarere og initialisere variabler med værdier ved hjælp af et lighedstegn.

fnvigtigste(){
lade alder: Snor = Snor::fra("fem år gammel");
lade alder = 5; // svarende til lad alder: i32 = 5;
println!("{}", alder);
}

Programmet erklærer to alder variabler før udskrivning med println! makro. Den første alder variabel angiver datatypen, og den anden gør det ikke.

Du behøver ikke at angive datatypen for en variabel, når du erklærer den. Rust-kompileren udleder typen fra værdiens datatype på kompileringstidspunktet.

Du kan også erklære konstanter i Rust med konst søgeord på samme måde som at erklære variabler:

konst alder: &str = "fem år gammel";

Du kan ikke ændre værdien af ​​en variabel, du erklærer som en konstant.

Rust giver funktionalitet til enkeltlinje- og blokkommentarer. Du kan bruge dobbelte skråstreger (//) for enkeltlinjekommentarer:

fnvigtigste() {
// Dette er en linjekommentar
lade x = 5; // Denne kommentar forklarer formålet med "x"-variablen
}

For kommentarer med flere linjer (blokkommentarer) skal du bruge en skråstreg efterfulgt af en stjerne (/*) og luk blokken med en stjerne efterfulgt af en skråstreg (*/):

fnvigtigste() {
/*
 Dette er en blokkommentar, der strækker sig over flere linjer.
 Det bruges ofte til at beskrive en større kodeblok.
 */
lade x = 5;
}

Dine kommentarer skal være kortfattede og ligetil.

Arrays i Rust

Arrays er en samling af fast størrelse af elementer af samme datatype. Rust allokerer arrays på stakken som standard.

Sådan kan du erklære arrays i Rust:

fnvigtigste() {
lade tal = [1, 2, 3, 4, 5];
}

Det tal array indeholder fem elementer. Du kan få adgang til værdien på et sted i et array ved hjælp af dets indeks:

fnvigtigste() {
lade tal = [1, 2, 3, 4, 5];
lade x = tal[3];
println!("{}", x)
}

Det vigtigste funktion udskriver x variabel, der får adgang til det fjerde element i arrayet.

Vektorer i Rust

Rust giver vektorer til at dække over begrænsningerne af arrayet. Vektorer har en dynamisk størrelse; de kan vokse og skrumpe efter behov.

Sådan kan du erklære vektorer i Rust:

fnvigtigste() {
lade min_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
lade x = min_vec[3];
println!("{}", x)
}

Det min_vec vektor er en vektor af 32-bit heltal. Det x variabel får adgang til vektorens fjerde element, og vigtigste funktion udskriver værdien til konsollen.

Rusts betingede erklæringer

Betingede erklæringer er en af Rusts kontrolstrukturer til beslutningstagning i programmer. Du kan bruge hvis og andet nøgleord til at håndtere beslutninger i dine programmer.

Her er en hvis sætning, der udskriver en streng til konsollen baseret på ligheden mellem to heltal.

fnvigtigste() {
lade en: i32 = 12;
hvis a == 12 {
println!("a er lig med tolv");
 }
}

Det vigtigste funktion udskriver strengen med println! makro, da variablen er lig med 12.

Du kan bruge andet nøgleord til at håndtere sager, hvor hvis udsagn vurderer falsk:

fnvigtigste() {
lade en: i32 = 12;
hvis a == 123 {
println!("a er lig med tolv");
 } andet {
println!("a er ikke lig med tolv");
 }
}

I dette eksempel er andet sætning kører, fordi a's værdi ikke er lig med 123.

Du kan erklære matcherklæringer med match nøgleord for komplekse betingede betingelser:

fnvigtigste() {
lade alder: i32 = 7;
match alder {
1 => println!("en"),
2 => println!("to"),
3 => println!("tre"),
 _ => println!("nul"),
 }
}

Det vigtigste funktion matcher alder variabel til tilfælde i match sætning og udfører det udtryk, der matcher værdien. Understregningen (_) er standardsætningen, der kører, hvis der er et match for værdien.

Sløjfer i Rust

Rust giver sløjfer til gentagne opgaver. Rust har tre hovedtyper af sløjfer: sløjfe, mens, og til sløjfer.

Det sløjfe nøgleordet opretter en uendelig løkke, der kører, indtil den støder på et pausenøgleord:

fnvigtigste() {
sløjfe {
println!("udskrives gentagne gange, indtil pauseerklæring er stødt på.");
pause;
 }
}

Det mens loop er praktisk, når du vil gentage en kodeblok, så længe en betingelse evalueres til sand:

fnvigtigste() {
lademut tælle = 0;
mens tælle < 5 {
println!("Antallet er {}", tælle);
 tælle += 1;
 }
}

EN til loop er god til iteration over en samling af elementer, såsom en matrix:

fnvigtigste() {
lade tal = [1, 2, 3, 4, 5];
til vare i tal.iter() {
println!("Det aktuelle element er {}", vare);
 }
}

Det her til loop itererer gennem tal array og udskriver hvert element til konsollen.

Erklære og kalde rustfunktioner

Brug fn nøgleord til erklære en rustfunktion, efterfulgt af funktionsnavnet, en liste over parametre og en returtype (hvis nogen).

Sådan kan du erklære en funktion med parametre og en returtype:

fntilføje(en: i32, b: i32) -> i32 {
Vend tilbage a + b;
}

Det tilføje funktion indtager to 32-bit heltal og returnerer et 32-bit heltal, summen af ​​de to parametre.

For at kalde en funktion fra et andet sted i din kode, skal du blot angive navnet og argumenterne (hvis nogen):

fnvigtigste() {
lade resultat = tilføje(2, 3);
println!("2 + 3 = {}", resultat);
}

Det resultat variabel holder resultatet fra at kalde tilføje fungere. Det vigtigste funktionen udskriver resultatet til konsollen ved hjælp af println! makro.

Bygninger i Rust

Rust giver strukturer til at definere brugerdefinerede datatyper, der grupperer relaterede værdier. Strukturer er tegninger til at skabe objekter med specifikke egenskaber.

Sådan kan du erklære en struktur:

strukturPerson {
 navn: Snor,
 alder: u32,
 er_mand: bool,
}

Det Person struct har tre felter: en streng, et 32-bit heltal uden fortegn og et boolesk tal.

Efter at have defineret en struktur, kan du oprette forekomster af den i andre dele af dit program:

fnvigtigste() {
lade person1 = Person {
 navn: Snor::fra("Candace Flynn"),
 alder: 16,
 er_mand: falsk,
 };
}

Det person1 variabel er en forekomst af Person struktur. Ved instansiering kan du tildele værdier til struct-felterne. Du kan oprette så mange forekomster af en struktur, som du vil.

Du kan implementere OOP-koncepter i rust

Rust er fleksibelt, og du kan implementere OOP-koncepterne i Rust med indbyggede datastrukturer som structs.

Du vil bruge strukturer som et alternativ til klasser. Med Rusts struct kan du definere en blueprint for typen og implementere de forskellige OOP-koncepter med de funktionaliteter Rust giver på structs.