Viss, kas jums jāzina, lai sāktu rakstīt Rust

Kopš iznākšanas 2015. gadā Rust ir ieguvis popularitāti kā viena no iecienītākajām izstrādātāju programmēšanas valodām. Rust piedāvā izcilas veiktspējas un drošības funkcijas ar intuitīvu un kodolīgu sintaksi, kas padara valodu vēlamu.

Rust ir piemērots dažādu programmu, tostarp tīmekļa lietotņu, komandrindas rīku un tīkla pakalpojumu, izveidei. Rust ietver daudzas funkcijas, kuras jūs sagaidāt no modernas programmēšanas valodas, piemēram, vienlaicīgumu, tipa secinājumus un daudz ko citu.

Darba sākšana ar Rust

Rust ir starpplatformu programmēšanas valoda, kas darbojas lielākajā daļā operētājsistēmu. Lai sāktu darbu ar Rust, dodieties uz ierēdni Rust vietne un instalējiet savai operētājsistēmai vēlamo versiju.

Kad esat instalējis Rust, varat sākt rakstīt programmas Rust failos ar a .rs pagarinājumu. Rūsa ir daudzpusīga un viegli apgūstama. Tas būs vienkārši, ja jums ir iepriekšēja programmēšanas pieredze.

Mainīgie un konstantes rūsā

Rūsa ir ļoti izteiksmīga, un ir vairāki veidi, kā deklarēt mainīgos. Jūs varat izmantot ļaut atslēgvārds mainīgo deklarēšanai.

Lūk, kā Rust var deklarēt mainīgos:

ļaut a: Stīga;
ļaut b: i32;
ļaut c: () = ();

The a un b mainīgie ir attiecīgi virkne un vesels skaitlis. The c Mainīgais ir Rust vienības tips, kas darbojas kā funkciju un izteiksmju vietturis.

Pēc izvēles datu tipa deklarācijas varat deklarēt un inicializēt mainīgos ar vērtībām, izmantojot vienādības zīmi.

fngalvenais(){
ļaut vecums: Stīga = Stīga::no("piecus gadus vecs");
ļaut vecums = 5; // līdzvērtīgs izīrēšanas vecumam: i32 = 5;
println!("{}", vecums);
}

Programma deklarē divus vecums mainīgie pirms drukāšanas ar println! makro. Pirmais vecums mainīgais norāda datu tipu, bet otrais nē.

Jums nav jānorāda mainīgā datu tips, kad to deklarējat. Rust kompilators secina veidu no vērtības datu veida kompilēšanas laikā.

Varat arī deklarēt konstantes Rust ar konst atslēgvārds līdzīgi kā mainīgo deklarēšana:

konst vecums: &str = "piecus gadus vecs";

Jūs nevarat mainīt tā mainīgā vērtību, kuru deklarējat kā konstanti.

Rust nodrošina vienas rindiņas un bloku komentāru funkcionalitāti. Varat izmantot dubultās slīpsvītras (//) vienas rindiņas komentāriem:

fngalvenais() {
// Šis ir rindiņas komentārs
ļaut x = 5; // Šis komentārs izskaidro mainīgā “x” mērķi
}

Vairāku rindiņu komentāriem (komentāru bloķēšanai) izmantojiet slīpsvītru, kam seko zvaigznīte (/*) un aizveriet bloku ar zvaigznīti, kam seko slīpsvītra (*/):

fngalvenais() {
/*
 Šis ir bloka komentārs, kas aptver vairākas rindiņas.
 To bieži izmanto, lai aprakstītu lielāku koda bloku.
 */
ļaut x = 5;
}

Jūsu komentāriem jābūt kodolīgiem un skaidriem.

Masīvi rūsā

Masīvi ir fiksēta izmēra viena datu tipa elementu kolekcija. Rust pēc noklusējuma piešķir masīvus kaudzē.

Lūk, kā Rust var deklarēt masīvus:

fngalvenais() {
ļaut cipari = [1, 2, 3, 4, 5];
}

The cipariem masīvā ir pieci vienumi. Varat piekļūt vērtībai masīva vietā, izmantojot tā indeksu:

fngalvenais() {
ļaut cipari = [1, 2, 3, 4, 5];
ļaut x = skaitļi[3];
println!("{}", x)
}

The galvenais funkcija izdrukā x mainīgais, kas piekļūst masīva ceturtajam elementam.

Vektori rūsā

Rust nodrošina vektorus, lai slēptu masīva ierobežojumus. Vektori ir dinamiski izmērīti; tie var augt un sarukt pēc vajadzības.

Lūk, kā Rust var deklarēt vektorus:

fngalvenais() {
ļaut my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
ļaut x = mans_vec[3];
println!("{}", x)
}

The my_vec vektors ir 32 bitu veselu skaitļu vektors. The x mainīgais piekļūst vektora ceturtajam elementam un galvenais funkcija izdrukā vērtību konsolei.

Rustas nosacījuma paziņojumi

Nosacīti apgalvojumi ir viens no Rūsas kontroles struktūras lēmumu pieņemšanai programmās. Jūs varat izmantot ja un cits atslēgvārdus, lai pieņemtu lēmumus jūsu programmās.

Šeit ir an ja paziņojums, kas konsolē izdrukā virkni, pamatojoties uz divu veselu skaitļu vienādību.

fngalvenais() {
ļaut a: i32 = 12;
ja a == 12 {
println!("a ir vienāds ar divpadsmit");
 }
}

The galvenais funkcija izdrukā virkni ar println! makro, jo mainīgais ir vienāds ar 12.

Jūs varat izmantot cits atslēgvārds, lai apstrādātu gadījumus, kad ja apgalvojums novērtē nepatiesi:

fngalvenais() {
ļaut a: i32 = 12;
ja a == 123 {
println!("a ir vienāds ar divpadsmit");
 } cits {
println!("a nav vienāds ar divpadsmit");
 }
}

Šajā piemērā cits paziņojums tiek izpildīts, jo a vērtība nav vienāda ar 123.

Jūs varat deklarēt atbilstības paziņojumus ar atbilst atslēgvārds sarežģītiem nosacījumiem:

fngalvenais() {
ļaut vecums: i32 = 7;
atbilst vecums {
1 => println!("viens"),
2 => println!("divi"),
3 => println!("trīs"),
 _ => println!("nulle"),
 }
}

The galvenais funkcija atbilst vecums mainīgs atkarībā no gadījumiem atbilst paziņojumu un izpilda izteiksmi, kas atbilst vērtībai. Pasvītra (_) ir noklusējuma priekšraksts, kas tiek izpildīts, ja vērtība atbilst.

Cilpas rūsā

Rūsa nodrošina cilpas atkārtotiem uzdevumiem. Rūsai ir trīs galvenie cilpu veidi: cilpa, kamēr, un priekš cilpas.

The cilpa atslēgvārds izveido bezgalīgu cilpu, kas darbojas, līdz tiek konstatēts pārtraukuma atslēgvārds:

fngalvenais() {
cilpa {
println!("drukā atkārtoti, līdz tiek konstatēts pārtraukuma paziņojums.");
pārtraukums;
 }
}

The kamēr cilpa ir noderīga, ja vēlaties atkārtot koda bloku, kamēr nosacījums tiek novērtēts kā patiess:

fngalvenais() {
ļautmut skaits = 0;
kamēr skaitīt < 5 {
println!("Skaits ir {}", skaitīt);
 skaits += 1;
 }
}

A priekš cilpa ir piemērota vienumu kolekcijas atkārtošanai, piemēram, masīvam:

fngalvenais() {
ļaut cipari = [1, 2, 3, 4, 5];
priekš lieta iekšā numbers.iter() {
println!("Pašreizējais vienums ir {}", lieta);
 }
}

Šis priekš cilpa atkārtojas caur cipariem masīvs un izdrukā katru vienumu konsolē.

Rūsas funkciju deklarēšana un izsaukšana

Izmantojiet fn atslēgvārds uz deklarēt Rust funkciju, kam seko funkcijas nosaukums, parametru saraksts un atgriešanas veids (ja tāds ir).

Lūk, kā jūs varat deklarēt funkciju ar parametriem un atgriešanas veidu:

fnpievienot(a: i32, b: i32) -> i32 {
atgriezties a + b;
}

The pievienot funkcija ņem divus 32 bitu veselus skaitļus un atgriež 32 bitu veselu skaitli, divu parametru summu.

Lai izsauktu funkciju no citas vietas kodā, vienkārši norādiet nosaukumu un argumentus (ja tādi ir):

fngalvenais() {
ļaut rezultāts = add(2, 3);
println!("2 + 3 = {}", rezultāts);
}

The rezultāts mainīgais satur izsaukšanas rezultātu pievienot funkciju. The galvenais funkcija izdrukā rezultātu konsolē, izmantojot println! makro.

Konstrukcijas rūsā

Rust nodrošina struktūras pielāgotu datu tipu definēšanai, kas grupē saistītās vērtības. Struktūras ir rasējumi, lai izveidotu objektus ar noteiktām īpašībām.

Lūk, kā jūs varat deklarēt struktūru:

struktūraPersona {
 nosaukums: Stīga,
 vecums: u32,
 is_male: bool,
}

The Persona struct ir trīs lauki: virkne, neparakstīts 32 bitu vesels skaitlis un Būla vērtība.

Pēc struktūras definēšanas varat izveidot tās gadījumus citās programmas daļās:

fngalvenais() {
ļaut persona1 = persona {
 nosaukums: Stīga::no("Kendisa Flinna"),
 vecums: 16,
 is_male: viltus,
 };
}

The persona1 mainīgais ir gadījums Persona struktūra. Instantiācijā varat piešķirt vērtības struct laukiem. Varat izveidot tik daudz struktūras gadījumu, cik vēlaties.

Jūs varat ieviest OOP koncepcijas Rust

Rust ir elastīgs, un jūs varat ieviest OOP koncepcijas programmā Rust ar iebūvētām datu struktūrām, piemēram, struktūrām.

Jūs izmantosit struktūras kā alternatīvu nodarbībām. Izmantojot Rust struktūru, varat definēt tipa projektu un ieviest dažādas OOP koncepcijas ar funkcionalitātēm, ko Rust nodrošina struktūrās.