Alt du trenger å vite for å begynne å skrive rust

Siden utgivelsen i 2015 har Rust blitt populær som et av favorittprogrammeringsspråkene til utviklere. Rust tilbyr utmerket ytelse og sikkerhetsfunksjoner med intuitiv og kortfattet syntaks som gjør språket ønskelig.

Rust er egnet for å bygge ulike programmer, inkludert webapper, kommandolinjeverktøy og nettverkstjenester. Rust inkluderer mange funksjoner du kan forvente fra et moderne programmeringsspråk, som samtidighet, typeslutning og mer.

Komme i gang med rust

Rust er et programmeringsspråk på tvers av plattformer som kjører på de fleste operativsystemer. For å komme i gang med Rust, gå til tjenestemannen Rust nettsted og installer den foretrukne versjonen for ditt operativsystem.

Når du har installert Rust, kan du begynne å skrive programmer i Rust-filer med en .rs Utvidelse. Rust er allsidig og lett å lære. Du vil finne det enkelt hvis du har tidligere erfaring med programmering.

Variabler og konstanter i rust

Rust er svært uttrykksfulle, og det er flere måter å deklarere variabler på. Du kan bruke la nøkkelord for å deklarere variabler.

Slik kan du deklarere variabler i Rust:

la en: String;
la b: i32;
la c: () = ();

De en og b variabler er henholdsvis en streng og et heltall. De c variabel er en rustenhetstype som fungerer som en plassholder for funksjoner og uttrykk.

Etter den valgfrie datatypedeklarasjonen kan du deklarere og initialisere variabler med verdier ved å bruke et likhetstegn.

fnhoved-(){
la alder: String = String::fra("fem år gammel");
la alder = 5; // tilsvarende la alder: i32 = 5;
println!("{}", alder);
}

Programmet erklærer to alder variabler før utskrift med println! makro. Den første alder variabelen spesifiserer datatypen, og den andre gjør det ikke.

Du trenger ikke å spesifisere datatypen til en variabel når du erklærer den. Rust-kompilatoren utleder typen fra verdiens datatype på kompileringstidspunktet.

Du kan også erklære konstanter i Rust med konst søkeord på lignende måte som å deklarere variabler:

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

Du kan ikke endre verdien til en variabel du erklærer som en konstant.

Rust gir funksjonalitet for enkeltlinje- og blokkkommentarer. Du kan bruke doble skråstreker (//) for kommentarer på én linje:

fnhoved-() {
// Dette er en linjekommentar
la x = 5; // Denne kommentaren forklarer hensikten med "x"-variabelen
}

For kommentarer med flere linjer (blokkkommentarer), bruk en skråstrek etterfulgt av en stjerne (/*) og lukk blokken med en stjerne etterfulgt av en skråstrek (*/):

fnhoved-() {
/*
 Dette er en blokkkommentar som spenner over flere linjer.
 Det brukes ofte til å beskrive en større blokk med kode.
 */
la x = 5;
}

Kommentarene dine bør være kortfattede og enkle.

Arrays i Rust

Matriser er en samling av elementer av samme datatype i fast størrelse. Rust tildeler matriser på stabelen som standard.

Slik kan du deklarere matriser i Rust:

fnhoved-() {
la tall = [1, 2, 3, 4, 5];
}

De tall array inneholder fem elementer. Du kan få tilgang til verdien på et sted i en matrise ved å bruke dens indeks:

fnhoved-() {
la tall = [1, 2, 3, 4, 5];
la x = tall[3];
println!("{}", x)
}

De hoved- funksjonen skriver ut x variabel som får tilgang til det fjerde elementet i matrisen.

Vektorer i Rust

Rust gir vektorer for å dekke opp begrensningene til matrisen. Vektorer er dynamisk størrelse; de kan vokse og krympe etter behov.

Slik kan du deklarere vektorer i Rust:

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

De min_vec vektor er en vektor av 32-biters heltall. De x variabelen får tilgang til vektorens fjerde element, og hoved- funksjonen skriver ut verdien til konsollen.

Rusts betingede erklæringer

Betingede utsagn er en av Rusts kontrollstrukturer for beslutningstaking i programmer. Du kan bruke hvis og ellers nøkkelord for å håndtere beslutninger i programmene dine.

Her er en hvis setning som skriver ut en streng til konsollen basert på likheten mellom to heltall.

fnhoved-() {
la en: i32 = 12;
hvis a == 12 {
println!("a er lik tolv");
 }
}

De hoved- funksjonen skriver ut strengen med println! makro siden variabelen er lik 12.

Du kan bruke ellers nøkkelord for å håndtere saker der hvis setningen vurderer falsk:

fnhoved-() {
la en: i32 = 12;
hvis a == 123 {
println!("a er lik tolv");
 } ellers {
println!("a er ikke lik tolv");
 }
}

I dette eksemplet er ellers setningen kjører fordi verdien til a ikke er lik 123.

Du kan erklære samsvarsuttalelser med kamp nøkkelord for komplekse betingelser:

fnhoved-() {
la alder: i32 = 7;
kamp alder {
1 => println!("en"),
2 => println!("to"),
3 => println!("tre"),
 _ => println!("null"),
 }
}

De hoved- funksjonen samsvarer med alder variabel til tilfeller i kamp setningen og utfører uttrykket som samsvarer med verdien. Understrekingen (_) er standardsetningen som kjøres hvis det er samsvar for verdien.

Løkker i Rust

Rust gir løkker for repeterende oppgaver. Rust har tre hovedtyper løkker: Løkke, samtidig som, og til løkker.

De Løkke nøkkelordet oppretter en uendelig sløyfe som kjører til den møter et pausenøkkelord:

fnhoved-() {
Løkke {
println!("skrives ut gjentatte ganger inntil brudderklæringen oppdages.");
gå i stykker;
 }
}

De samtidig som loop er nyttig når du vil gjenta en kodeblokk så lenge en betingelse evalueres til sann:

fnhoved-() {
lamut telle = 0;
samtidig som telle < 5 {
println!("Antallet er {}", telle);
 telle += 1;
 }
}

EN til loop er bra for å iterere over en samling av elementer, som en matrise:

fnhoved-() {
la tall = [1, 2, 3, 4, 5];
til punkt i tall.iter() {
println!("Gjeldende element er {}", element);
 }
}

Dette til loop itererer gjennom tall array og skriver ut hvert element til konsollen.

Deklarere og kalle rustfunksjoner

Bruke fn nøkkelord til erklære en Rust-funksjon, etterfulgt av funksjonsnavnet, en liste over parametere og en returtype (hvis noen).

Slik kan du deklarere en funksjon med parametere og en returtype:

fnLegg til(en: i32, b: i32) -> i32 {
komme tilbake a + b;
}

De Legg til funksjonen tar inn to 32-bits heltall og returnerer et 32-bits heltall, summen av de to parameterne.

For å kalle en funksjon fra et annet sted i koden din, spesifiser du bare navnet og argumentene (hvis noen):

fnhoved-() {
la resultat = legg til(2, 3);
println!("2 + 3 = {}", resultat);
}

De resultat variabel holder resultatet fra å kalle Legg til funksjon. De hoved- funksjonen skriver ut resultatet til konsollen ved hjelp av println! makro.

Strukturer i Rust

Rust gir strukturer for å definere egendefinerte datatyper som grupperer relaterte verdier. Strukturer er tegninger for å lage objekter med spesifikke egenskaper.

Slik kan du erklære en struktur:

strukturPerson {
 Navn: String,
 alder: u32,
 er_mann: bool,
}

De Person struct har tre felt: en streng, et usignert 32-bits heltall og et boolsk.

Etter å ha definert en struktur, kan du opprette forekomster av den i andre deler av programmet:

fnhoved-() {
la person1 = Person {
 Navn: String::fra("Candace Flynn"),
 alder: 16,
 er_mann: falsk,
 };
}

De person1 variabel er en forekomst av Person struktur. Ved instansiering kan du tilordne verdier til struct-feltene. Du kan lage så mange forekomster av en struktur du vil.

Du kan implementere OOP-konsepter i rust

Rust er fleksibelt, og du kan implementere OOP-konseptene i Rust med innebygde datastrukturer som strukturer.

Du vil bruke strukturer som et alternativ til klasser. Med Rusts struktur kan du definere en blåkopi for typen og implementere de forskjellige OOP-konseptene med funksjonaliteten Rust gir på strukturer.