Rust yra statinio tipo moderni programavimo kalba, sukurta siekiant užtikrinti našumą, patikimumą ir saugumą. Kaip ir kitose statiškai įvestose kalbose, Rust duomenų tipus deklaruojate kompiliavimo metu. Taip lengviau pastebėti tipo klaidas prieš paleidžiant kodą.
Rust siūlo skaliarinius, sudėtinius, nuorodų tipus, struktūras, enumus ir eilutes. Jo tipo išvada suteikia galimybę rašyti glaustą kodą, išlaikant statinio tipo kalbos saugumą.
Sveikieji skaičiai rūdyje
Rust pateikia pasirašytų ir nepasirašytų sveikųjų skaičių tipus, klasifikuojamus pagal bitų skaičių. Ženkliniai sveikųjų skaičių tipai yra i8, i16, i32, ir i64 atstovaujantys atitinkamai 8 bitų, 16 bitų, 32 bitų ir 64 bitų sveikuosius skaičius. Jis taip pat palaiko nepažymėtus sveikųjų skaičių tipus u8, u16, u32, ir u64, reiškia 8 bitų, 16 bitų, 32 bitų ir 64 bitų beženklius sveikuosius skaičius.
// pasirašyti sveikieji skaičiai
leisti a: i8 = -10;
leisti b: i16 = -2048;
leisti c: i32 = -2147483648;
leisti d: i64 = -9223372036854775808;
// sveikieji skaičiai be ženklų
leisti e: u8 = 255;
leisti f: u16 = 65535;
leisti g: u32 = 4294967295;
leisti h: u64 = 18446744073709551615;
Rust naudoja i32 pagal numatytuosius nustatymus įveskite sveikųjų skaičių literalą.
Rūdžių slankiojo kablelio tipai
Rūdys suteikia f32 ir f64 kaip slankiojo kablelio tipus, vaizduojančius vieno tikslumo ir dvigubo tikslumo slankiojo kablelio skaičius. The f32 tipas naudoja 32 bitus reikšmėms saugoti, o f64 tipas naudoja 64 bitus.
Slankaus kablelio skaičiai Rust atitinka IEEE 754 standartą, skirtą slankiojo kablelio aritmetikai.
leisti a = 3.14159265358979323_f32;
leisti b = 2.718281828459045235_f64;
Naudojant Rust Booleans
Rūdys suteikia a bool tipo atstovauti tiesa arba klaidinga vertybes. Būlio reikšmės dažnai naudojamos sąlyginiuose ir valdymo srauto sakiniuose priimant programos sprendimus.
leisti kintamasis_1: bool = tiesa;
leisti kintamasis_2: bool = klaidinga;
Galite palyginti logines vertes su lygybės operatoriumi, ==ir nelygybės operatorius, !=. Rust neapibrėžia palyginimo operatorių, , <=, ir >=, dėl bool vertybes.
leisti kintamasis_1: bool = tiesa;
leisti kintamasis_2: bool = klaidinga;
if kintamasis_1 == kintamasis_2 {
spausdinti!("kintamasis_1 yra lygus kintamajam_2");
} Kitasjeigu kintamasis_1 != kintamasis_2 {
spausdinti!("kintamasis_1 nėra lygus kintamajam_2");
}
Char tipas
Rūdys char tipas reiškia vieną Unicode skaliarinę reikšmę, kuri gali reikšti bet kurį simbolį Unicode standartą. Galite nurodyti a char vertė naudojant atskiras kabutes.
// Char reikšmės deklaravimas
leisti c = 'a';
The char tipas yra naudingas dirbant su jaustukais „Rust“.
Korpusai rūdyje
Kortelės duomenų struktūra leidžia sugrupuoti daugiau nei vieną reikšmę į vieną sudėtinę reikšmę. Šios reikšmės gali būti to paties tipo arba skirtingų tipų. Galite deklaruoti eilutes rašydami jas kaip kableliais atskirtą reikšmių sąrašą, apsuptą skliaustuose.
Štai kaip galite deklaruoti seką su 32 bitų sveikaisiais skaičiais, eilutėmis ir float64 reikšmėmis.
leisti tup: (i32, &str, f64) = (500, "Sveiki", 3.14);
Kortelės yra fiksuoto ilgio ir jas galite naudoti norėdami grąžinti kelias funkcijos reikšmes arba perduoti kelias reikšmes funkcijoms kaip vieną argumentą.
Galite pasiekti atskirus rinkinio elementus sunaikindami jį naudodami šablonų atitikimą arba tiesiogiai pasiekite atskirus elementus naudodami taško (.) sintaksę ir indeksą.
Štai kaip galite pasiekti atskirus struktūros elementus naudodami modelio atitikimą:
leisti my_tuple = (10, "Labas pasauli!", klaidinga);leisti (x, y, z) = mano_eilė;
spausdinti!("Pirmasis elementas yra: {}", x);
spausdinti!("Antrasis elementas yra: {}", y);
spausdinti!("Trečias elementas yra: {}", z);
Štai kaip galite pasiekti atskirus elementus naudodami taškų žymėjimą:
leisti my_tuple = (10, "Labas pasauli!", klaidinga);
println!("ThePirmaselementasyra: {}", mano_tuple.0);
println!("Theantraelementasyra: {}", mano_tuple.1);
println!("Thetrečiaselementasyra: {}", mano_tuple.2);
Kortelės yra labai naudingos grupuojant susijusius duomenis į vieną reikšmę. Jie taip pat gali pagerinti kodo skaitomumą, jei juos naudosite taupiai.
Rūdžių masyvai
Masyvas yra to paties tipo elementų, turinčių fiksuotą ilgį, rinkinys. Rust matricas rašote kaip reikšmių sąrašą laužtiniuose skliaustuose, atskirtus kableliais.
Štai kaip galite deklaruoti masyvus Rust:
leisti arr = [1, 2, 3, 4, 5];
Negalite keisti elementų skaičiaus masyve, kai jį deklaruojate, bet galite pasiekti, keisti ir valdyti atskirus masyvo elementus naudodami indeksavimą.
leisti mut my_array = [1, 2, 3, 4, 5];// Prieiga prie elementų
println!("ThePirmaselementasyra: {}", mano_masyvas[0]);// Elementų keitimas
mano_masyvas[0] = 100;
println!("ThePirmaselementaspo tomodifikacijayra: {}", mano_masyvas[0]);// Perėjimas per masyvą ir manipuliavimas elementais
dėliin 0..mano_masyvas.len() {
mano_masyvas[i] *= 2;
}
// masyvo spausdinimas
spausdinti!("Masyvas po manipuliavimo: {:?}", mano_masyvas);
Rūdžių masyvai yra saugomi ant kamino ir turėti gretimą atminties paskirstymą, todėl prieiga prie masyvo elementų yra greita ir efektyvi. Dėl to masyvai tinka situacijose, kai reikia saugoti ir apdoroti daug elementų.
Darbas su rūdžių skiltelėmis
Pjūvis yra duomenų struktūra, leidžianti nurodyti gretimą kolekcijos elementų seką. Skilteles žymi &[T] tipas, kur T yra skiltyje saugomų elementų tipas.
fn pagrindinis(){
// deklaruoti masyvą
leisti mano_masyvas = [1, 2, 3, 4, 5];// sukurti iš masyvo atkarpą
leisti my_slice = &mano_masyvas[1..3];
// atspausdinti skiltį
spausdinti!("Slice: {:?}", my_slice);
}
Atkreipkite dėmesį, kaip diapazono sintaksė, .., iš masyvo ištraukia atkarpą naudodamas pradinį indeksą ir indeksą, didesnį už pabaigą:
Pjūviai yra dinamiški, todėl Rust gali nustatyti jų ilgį vykdymo metu. Taip pat galite perduoti dalis kaip argumentus funkcijoms, nereikalaujant krūvos paskirstymo.
Paprastai skirsnius naudosite eilučių operacijoms ir duomenų pogrupiams perduoti funkcijoms. Jie yra galingas ir efektyvus kolekcijų tvarkymo „Rust“ įrankis, suteikiantis lankstesnę masyvų alternatyvą.
„Rust“ galite sukurti „WebAssembly“ valdomas „frontend“ žiniatinklio programas
Duomenų tipų žinios yra labai svarbios jūsų „Rust“ kelionėje, nes jas naudosite daugumoje operacijų kurdami programas.
„WebAssembly“ yra žemo lygio dvejetainis formatas, veikiantis šiuolaikinėse žiniatinklio naršyklėse ir pasižymintis beveik vietiniu našumu. Tai leidžia rašyti kodą daugeliu skirtingų kalbų ir perkelti jį į WebAssembly.
„WebAssembly“ vis labiau populiarėja per „Rust“. Yra daug sistemų, pvz., Yew, Sycamore ir Seed, kurias galite naudoti kurdami WebAssembly maitinamas sąsajas su Rust.