Viskas, ką reikia žinoti norint pradėti rašyti Rust

Nuo pat išleidimo 2015 m., Rust išpopuliarėjo kaip viena mėgstamiausių kūrėjų programavimo kalbų. Rust siūlo puikų našumą ir saugos funkcijas su intuityvia ir glausta sintaksė, dėl kurios kalba pageidautina.

Rust tinka kurti įvairias programas, įskaitant žiniatinklio programas, komandų eilutės įrankius ir tinklo paslaugas. Rust apima daug funkcijų, kurių tikitės iš šiuolaikinės programavimo kalbos, pvz., lygiagretumo, tipo išvados ir kt.

Darbo su rūdys pradžia

Rust yra kelių platformų programavimo kalba, kuri veikia daugelyje operacinių sistemų. Norėdami pradėti dirbti su Rust, eikite į pareigūną Rust svetainė ir įdiekite pageidaujamą operacinės sistemos versiją.

Įdiegę Rust, galite pradėti rašyti programas į Rust failus naudodami a .rs pratęsimas. Rūdys yra universalus ir lengvai išmokstamas. Tai bus paprasta, jei turite ankstesnės programavimo patirties.

Kintamieji ir konstantos rūdyje

Rūdys yra labai išraiškingos ir yra daug būdų deklaruoti kintamuosius. Galite naudoti leisti raktinis žodis kintamiesiems deklaruoti.

Štai kaip galite deklaruoti kintamuosius „Rust“:

leisti a: Styga;
leisti b: i32;
leisti c: () = ();

The a ir b kintamieji yra atitinkamai eilutė ir sveikasis skaičius. The c kintamasis yra „Rust“ vieneto tipas, kuris veikia kaip funkcijų ir išraiškų rezervavimo vieta.

Po pasirenkamo duomenų tipo deklaravimo galite deklaruoti ir inicijuoti kintamuosius su reikšmėmis naudodami lygybės ženklą.

fnpagrindinis(){
leisti amžius: Styga = Styga::nuo("penkerių metų");
leisti amžius = 5; // atitikmuo nuomos amžiui: i32 = 5;
println!("{}", amžius);
}

Programa skelbia du amžiaus kintamuosius prieš spausdinant su println! makrokomandą. Pirmas amžiaus kintamasis nurodo duomenų tipą, o antrasis – ne.

Nereikia nurodyti kintamojo duomenų tipo, kai jį deklaruojate. „Rust“ kompiliatorius daro išvadą apie tipą iš vertės duomenų tipo kompiliavimo metu.

Taip pat galite deklaruoti Rust konstantas su konst raktinį žodį panašiai kaip deklaruojant kintamuosius:

konst amžius: &g = "penkerių metų";

Negalite keisti kintamojo, kurį deklaruojate kaip konstantą, reikšmės.

Rust suteikia vienos eilutės ir blokinių komentarų funkcionalumą. Galite naudoti dvigubus pasviruosius brūkšnius (//) vienos eilutės komentarams:

fnpagrindinis() {
// Tai eilutės komentaras
leisti x = 5; // Šis komentaras paaiškina kintamojo „x“ paskirtį
}

Kelių eilučių komentarams (blokuoti komentarus) naudokite pasvirąjį brūkšnį ir žvaigždutę (/*) ir uždarykite bloką žvaigždute, po kurio pasviruoju brūkšniu (*/):

fnpagrindinis() {
/*
 Tai blokinis komentaras, apimantis kelias eilutes.
 Jis dažnai naudojamas apibūdinti didesnį kodo bloką.
 */
leisti x = 5;
}

Jūsų komentarai turi būti glausti ir tiesūs.

Rūdžių masyvai

Masyvai yra fiksuoto dydžio to paties duomenų tipo elementų rinkinys. Rust pagal numatytuosius nustatymus paskirsto masyvus rietuvėje.

Štai kaip galite deklaruoti masyvus Rust:

fnpagrindinis() {
leisti skaičiai = [1, 2, 3, 4, 5];
}

The numeriai masyvą sudaro penki elementai. Vertę galite pasiekti masyvo vietoje naudodami jo indeksą:

fnpagrindinis() {
leisti skaičiai = [1, 2, 3, 4, 5];
leisti x = skaičiai[3];
println!("{}", x)
}

The pagrindinis funkcija spausdina x kintamasis, pasiekiantis ketvirtąjį masyvo elementą.

Vektoriai rūdyje

Rust pateikia vektorius, kurie nuslėptų masyvo apribojimus. Vektoriai yra dinaminio dydžio; jie gali augti ir trauktis pagal poreikį.

Štai kaip galite deklaruoti vektorius Rust:

fnpagrindinis() {
leisti my_vec: Sen<i32> = vec![1, 2, 3, 4, 5];
leisti x = mano_vec[3];
println!("{}", x)
}

The mano_vec vektorius yra 32 bitų sveikųjų skaičių vektorius. The x kintamasis pasiekia ketvirtąjį vektoriaus elementą ir pagrindinis funkcija išspausdina reikšmę į konsolę.

Rusto sąlyginiai pareiškimai

Sąlyginiai teiginiai yra vienas iš Rūdžių valdymo struktūros sprendimų priėmimui programose. Galite naudoti jeigu ir Kitas raktinius žodžius, kad galėtumėte priimti sprendimus jūsų programose.

Štai an jeigu teiginys, kuris spausdina eilutę į konsolę pagal dviejų sveikųjų skaičių lygybę.

fnpagrindinis() {
leisti a: i32 = 12;
jeigu a == 12 {
println!("a lygus dvylikai");
 }
}

The pagrindinis funkcija atspausdina eilutę su println! makrokomandą, nes kintamasis lygus 12.

Galite naudoti Kitas raktinis žodis, skirtas tvarkyti atvejus, kai jeigu teiginys vertina klaidingą:

fnpagrindinis() {
leisti a: i32 = 12;
jeigu a == 123 {
println!("a lygus dvylikai");
 } Kitas {
println!("a nelygu dvylika");
 }
}

Šiame pavyzdyje Kitas teiginys vykdomas, nes a reikšmė nėra lygi 123.

Galite deklaruoti atitikties teiginius su rungtynės raktinis žodis sudėtingoms sąlygoms:

fnpagrindinis() {
leisti amžius: i32 = 7;
rungtynės amžius {
1 => println!("vienas"),
2 => println!("du"),
3 => println!("trys"),
 _ => println!("nulis"),
 }
}

The pagrindinis funkcija atitinka amžiaus kintamas pagal atvejus rungtynės sakinį ir vykdo reikšmę atitinkančią išraišką. Pabraukimas (_) yra numatytasis sakinys, kuris vykdomas, jei reikšmė atitinka.

Kilpos rūdyje

Rūdys suteikia kilpų pasikartojančioms užduotims atlikti. Rūdys turi tris pagrindinius kilpų tipus: kilpa, kol, ir dėl kilpos.

The kilpa raktinis žodis sukuria begalinį ciklą, kuris veikia tol, kol susiduria su pertraukos raktiniu žodžiu:

fnpagrindinis() {
kilpa {
println!("spausdinama pakartotinai, kol atsiranda pertraukos pareiškimas.");
pertrauka;
 }
}

The kol ciklas yra patogus, kai norite pakartoti kodo bloką tol, kol sąlyga įvertinama kaip tiesa:

fnpagrindinis() {
leistimut skaičiuoti = 0;
kol skaičiuoti < 5 {
println!("Skaičius yra {}", skaičiuoti);
 skaičiuoti += 1;
 }
}

A dėl ciklas tinka kartoti elementų kolekciją, pvz., masyvą:

fnpagrindinis() {
leisti skaičiai = [1, 2, 3, 4, 5];
dėl daiktas in skaičiai.iter() {
println!("Dabartinis elementas yra {}", prekė);
 }
}

Tai dėl ciklas kartojasi per numeriai masyvą ir atspausdina kiekvieną elementą į konsolę.

Rūdžių funkcijų deklaravimas ir iškvietimas

Naudoti fn raktažodis į paskelbti rūdžių funkciją, po kurio nurodomas funkcijos pavadinimas, parametrų sąrašas ir grąžinimo tipas (jei yra).

Štai kaip galite deklaruoti funkciją su parametrais ir grąžinimo tipu:

fnpapildyti(a: i32, b: i32) -> i32 {
grąžinti a + b;
}

The papildyti funkcija paima du 32 bitų sveikuosius skaičius ir grąžina 32 bitų sveikąjį skaičių, dviejų parametrų sumą.

Norėdami iškviesti funkciją iš kitos kodo vietos, tiesiog nurodykite pavadinimą ir argumentus (jei yra):

fnpagrindinis() {
leisti rezultatas = pridėti (2, 3);
println!("2 + 3 = {}", rezultatas);
}

The rezultatas kintamasis turi iškvietimo rezultatą papildyti funkcija. The pagrindinis funkcija išspausdina rezultatą į konsolę, naudodama println! makrokomandą.

Konstrukcijos rūdyje

Rust pateikia struktūras, skirtas apibrėžti pasirinktinius duomenų tipus, sugrupuojančius susijusias reikšmes. Struktūros yra tam tikrų savybių objektų kūrimo brėžiniai.

Štai kaip galite deklaruoti struktūrą:

struktūraAsmuo {
 vardas: Styga,
 amžius: u32,
 is_male: bool,
}

The Asmuo struct turi tris laukus: eilutę, beženklį 32 bitų sveikąjį skaičių ir loginį.

Apibrėžę struktūrą, galite sukurti jos egzempliorius kitose programos dalyse:

fnpagrindinis() {
leisti asmuo1 = asmuo {
 vardas: Styga::nuo("Candace Flynn"),
 amžius: 16,
 is_male: klaidinga,
 };
}

The asmuo1 kintamasis yra pavyzdys Asmuo struktūra. Instantiacijos metu galite priskirti reikšmes struktūros laukams. Galite sukurti tiek struktūros egzempliorių, kiek norite.

Galite įgyvendinti OOP koncepcijas „Rust“.

„Rust“ yra lanksti, o „Rust“ OOP koncepcijas galite įgyvendinti naudodami įmontuotas duomenų struktūras, pvz., struktūras.

Naudosite struktūras kaip alternatyvą klasėms. Naudodami „Rust“ struktūrą galite apibrėžti tipo planą ir įgyvendinti įvairias OOP koncepcijas su „Rust“ struktūrų teikiamomis funkcijomis.