Kõik, mida peate teadma rooste kirjutamise alustamiseks

Alates selle ilmumisest 2015. aastal on Rust populaarsust kogunud kui arendajate üks lemmikprogrammeerimiskeeli. Rust pakub suurepärast jõudlust ja turvafunktsioone koos intuitiivse ja kokkuvõtliku süntaksiga, mis muudavad keele soovitavaks.

Rust sobib erinevate programmide, sealhulgas veebirakenduste, käsureatööriistade ja võrguteenuste loomiseks. Rust sisaldab palju funktsioone, mida võite oodata kaasaegselt programmeerimiskeelelt, nagu samaaegsus, tüübi järeldamine ja palju muud.

Roostega alustamine

Rust on platvormideülene programmeerimiskeel, mis töötab enamikus operatsioonisüsteemides. Rustiga alustamiseks pöörduge ametniku poole Rooste veebisait ja installige oma operatsioonisüsteemi jaoks eelistatud versioon.

Kui olete Rusti installinud, saate alustada programmide kirjutamist Rust-failidesse, kasutades a .rs pikendamine. Rooste on mitmekülgne ja kergesti õpitav. See on lihtne, kui teil on eelnev programmeerimiskogemus.

Muutujad ja konstandid roostes

Rooste on väga väljendusrikas ja muutujate deklareerimiseks on mitu võimalust. Võite kasutada lase märksõna muutujate deklareerimiseks.

Siin saate Rustis muutujaid deklareerida:

lase a: String;
lase b: i32;
lase c: () = ();

The a ja b muutujad on vastavalt string ja täisarv. The c muutuja on Rust ühikutüüp, mis toimib funktsioonide ja avaldiste kohahoidjana.

Pärast valikulist andmetüübi deklaratsiooni saate muutujaid väärtustega deklareerida ja lähtestada võrdusmärgi abil.

fnpeamine(){
lase vanus: String = String::from("viieaastane");
lase vanus = 5; // samaväärne laenu vanusega: i32 = 5;
println!("{}", vanus);
}

Programm deklareerib kaks vanus muutujad enne rakendusega printimist println! makro. Esimene vanus muutuja määrab andmetüübi ja teine ​​mitte.

Te ei pea muutuja andmetüüpi selle deklareerimisel määrama. Rust-kompilaator järeldab tüübi väärtuse andmetüübi põhjal kompileerimise ajal.

Konstandid saate Rustis deklareerida ka käsuga konst märksõna sarnaselt muutujate deklareerimisega:

konst vanus: &str = "viieaastane";

Te ei saa muuta muutuja väärtust, mille deklareerite konstantina.

Rust pakub üherealiste ja plokkkommentaaride funktsioone. Võite kasutada topelt kaldkriipsu (//) üherealiste kommentaaride jaoks:

fnpeamine() {
// See on reakommentaar
lase x = 5; // See kommentaar selgitab muutuja x eesmärki
}

Mitmerealiste kommentaaride jaoks (blokeerige kommentaarid) kasutage kaldkriipsu, millele järgneb tärn (/*) ja sulgege plokk tärniga, millele järgneb kaldkriips (*/):

fnpeamine() {
/*
 See on blokeeritud kommentaar, mis hõlmab mitut rida.
 Seda kasutatakse sageli suurema koodiploki kirjeldamiseks.
 */
lase x = 5;
}

Teie kommentaarid peaksid olema lühikesed ja otsekohesed.

Massiivid roostes

Massiivid on sama andmetüübi elementide fikseeritud suurusega kogum. Rust eraldab vaikimisi virna massiivid.

Rustis massiivide deklareerimiseks tehke järgmist.

fnpeamine() {
lase numbrid = [1, 2, 3, 4, 5];
}

The numbrid massiiv sisaldab viit üksust. Väärtusele pääsete juurde massiivi asukohas selle indeksi abil:

fnpeamine() {
lase numbrid = [1, 2, 3, 4, 5];
lase x = numbrid[3];
println!("{}", x)
}

The peamine funktsioon prindib x muutuja, mis pääseb juurde massiivi neljandale elemendile.

Vektorid roostes

Rust pakub vektoreid massiivi piirangute varjamiseks. Vektorid on dünaamilise suurusega; nad võivad kasvada ja kahaneda vastavalt vajadusele.

Rustis vektoreid saab deklareerida järgmiselt:

fnpeamine() {
lase my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
lase x = minu_vec[3];
println!("{}", x)
}

The minu_vec vektor on 32-bitiste täisarvude vektor. The x muutuja pääseb juurde vektori neljandale elemendile ja peamine funktsioon prindib väärtuse konsooli.

Rusti tingimuslikud avaldused

Tingimuslikud väited on üks Rooste juhtimisstruktuurid programmides otsuste tegemiseks. Võite kasutada kui ja muidu märksõnad teie programmide otsuste tegemiseks.

Siin on an kui lause, mis prindib konsooli stringi kahe täisarvu võrdsuse alusel.

fnpeamine() {
lase a: i32 = 12;
kui a == 12 {
println!("a võrdub kaheteistkümnega");
 }
}

The peamine funktsioon prindib stringi println! makro, kuna muutuja on 12.

Võite kasutada muidu märksõna, mis käsitleb juhtumeid, kus kui väide hindab valet:

fnpeamine() {
lase a: i32 = 12;
kui a == 123 {
println!("a võrdub kaheteistkümnega");
 } muidu {
println!("a ei võrdu kaheteistkümnega");
 }
}

Selles näites on muidu lause töötab, kuna a väärtus ei ole võrdne 123-ga.

Saate deklareerida vaste avaldused vaste Märksõna keerukate tingimustingimuste jaoks:

fnpeamine() {
lase vanus: i32 = 7;
vaste vanus {
1 => println!("üks"),
2 => println!("kaks"),
3 => println!("kolm"),
 _ => println!("null"),
 }
}

The peamine funktsioon sobib vanus muutuv vastavalt juhtudele vaste lause ja täidab väärtusele vastava avaldise. Alakriips (_) on vaikelause, mis käivitatakse, kui väärtus vastab.

Silmused roostes

Rooste pakub silmuseid korduvate ülesannete jaoks. Roostel on kolm peamist tüüpi silmuseid: silmus, samas, ja jaoks silmuseid.

The silmus märksõna loob lõpmatu tsükli, mis jookseb seni, kuni kohtab murdemärksõna:

fnpeamine() {
silmus {
println!("prinditakse korduvalt, kuni ilmneb katkestuslause.");
murda;
 }
}

The samas tsükkel on mugav, kui soovite korrata koodiplokki seni, kuni tingimus on tõene:

fnpeamine() {
lasemut arv = 0;
samas loe < 5 {
println!("Arv on {}", loe);
 loe += 1;
 }
}

A jaoks tsükkel sobib hästi üksuste kogumi (nt massiivi) itereerimiseks:

fnpeamine() {
lase numbrid = [1, 2, 3, 4, 5];
jaoks üksus sisse numbers.iter() {
println!("Praegune üksus on {}", üksus);
 }
}

See jaoks tsükkel itereerib läbi numbrid massiivi ja prindib iga üksuse konsooli.

Roostefunktsioonide deklareerimine ja kutsumine

Kasuta fn märksõna kuulutada välja roostefunktsioon, millele järgneb funktsiooni nimi, parameetrite loend ja tagastustüüp (kui see on olemas).

Funktsiooni parameetrite ja tagastustüübiga deklareerimiseks tehke järgmist.

fnlisama(a: i32, b: i32) -> i32 {
tagasi a + b;
}

The lisama funktsioon võtab kaks 32-bitist täisarvu ja tagastab 32-bitise täisarvu, kahe parameetri summa.

Funktsiooni kutsumiseks mujalt koodis määrake lihtsalt nimi ja argumendid (kui neid on):

fnpeamine() {
lase tulemus = add(2, 3);
println!("2 + 3 = {}", tulemus);
}

The tulemus muutuja hoiab endas kutsumise tulemust lisama funktsiooni. The peamine funktsioon prindib tulemuse konsooli kasutades println! makro.

Konstruktsioonid roostes

Rust pakub struktuure kohandatud andmetüüpide määratlemiseks, mis rühmitavad seotud väärtusi. Struktuurid on kavandid konkreetsete omadustega objektide loomiseks.

Struktuuri deklareerimiseks tehke järgmist.

struktuurIsik {
 nimi: String,
 vanus: u32,
 is_male: bool,
}

The Isik structil on kolm välja: string, märgita 32-bitine täisarv ja tõeväärtus.

Pärast struktuuri määratlemist saate luua selle eksemplare oma programmi teistes osades.

fnpeamine() {
lase isik1 = isik {
 nimi: String::from("Candace Flynn"),
 vanus: 16,
 is_male: vale,
 };
}

The inimene 1 muutuja on eksemplar Isik struktuur. Instantimisel saate struktuuriväljadele väärtusi määrata. Saate luua nii palju struktuuri eksemplare, kui soovite.

Saate rakendada OOP-i kontseptsioone Roostes

Rust on paindlik ja saate OOP-i kontseptsioone Rustis rakendada sisseehitatud andmestruktuuridega, nagu struktuurid.

Kasutate klasside alternatiivina struktuure. Rusti struktuuriga saate määratleda tüübi kavandi ja rakendada erinevaid OOP kontseptsioone funktsioonidega, mida Rust struktuuridel pakub.