Rust ir statiski tipizēta moderna programmēšanas valoda, kas paredzēta veiktspējai, uzticamībai un drošībai. Tāpat kā citās statiski ievadītās valodās, Rust datu tipi tiek deklarēti kompilēšanas laikā. Tādējādi ir vieglāk uztvert tipa kļūdas pirms koda palaišanas.
Rust piedāvā skalārus, saliktos, atsauces veidus, struktūras, enumus un virknes. Tā tipa secinājums nodrošina funkcionalitāti īsa koda rakstīšanai, vienlaikus saglabājot statiski drukātas valodas drošību.
Veseli skaitļi rūsā
Rust nodrošina parakstītus un neparakstītus veselu skaitļu tipus, kas klasificēti, pamatojoties uz bitu skaitu. Parakstīto veselo skaitļu veidi ir i8, i16, i32, un i64 kas attēlo attiecīgi 8 bitu, 16 bitu, 32 bitu un 64 bitu zīmju veselus skaitļus. Tā atbalsta arī neparakstītu veselu skaitļu tipus u8, u16, u32, un u64, kas pārstāv 8 bitu, 16 bitu, 32 bitu un 64 bitu neparakstītus veselus skaitļus.
// veseli skaitļi ar parakstiem
ļaut a: i8 = -10;
ļaut b: i16 = -2048;
ļaut c: i32 = -2147483648;
ļaut d: i64 = -9223372036854775808;
// neparakstīti veseli skaitļi
ļaut e: u8 = 255;
ļaut f: u16 = 65535;
ļaut g: u32 = 4294967295;
ļaut h: u64 = 18446744073709551615;
Rust izmanto i32 pēc noklusējuma ievadiet veselus skaitļus.
Rūsas peldošā punkta veidi
Rūsa nodrošina f32 un f64 kā peldošā komata veidi, kas attēlo vienas precizitātes un dubultas precizitātes peldošā komata skaitļus. The f32 tips izmanto 32 bitus, lai saglabātu vērtības, un f64 tips izmanto 64 bitus.
Peldošā komata skaitļi Rust atbilst IEEE 754 standartam peldošā komata aritmētikai.
ļaut a = 3.14159265358979323_f32;
ļaut b = 2.718281828459045235_f64;
Rust Booleans izmantošana
Rūsa nodrošina a bool tips, kas jāatspoguļo taisnība vai viltus vērtības. Būla vērtības bieži tiek izmantotas nosacījuma un kontroles plūsmas priekšrakstos programmas lēmumu pieņemšanai.
ļaut mainīgais_1: bool = taisnība;
ļaut mainīgais_2: bool = viltus;
Jūs varat salīdzināt Būla vērtības ar vienlīdzības operatoru, ==, un nevienlīdzības operators, !=. Rust nedefinē salīdzināšanas operatorus, , <=, un >=, priekš bool vērtības.
ļaut mainīgais_1: bool = taisnība;
ļaut mainīgais_2: bool = viltus;
if mainīgais_1 == mainīgais_2 {
println!("mainīgais_1 ir vienāds ar mainīgo_2");
} citsja mainīgais_1 != mainīgais_2 {
println!("mainīgais_1 nav vienāds ar mainīgo_2");
}
Char tips
Rūsa char tips apzīmē vienu Unikoda skalāro vērtību, kas var attēlot jebkuru rakstzīmi Unikoda standarts. Jūs varat norādīt a char vērtību, izmantojot vienas pēdiņas.
// Char vērtības deklarēšana
ļaut c = "a";
The char veids ir noderīgs, strādājot ar emocijzīmēm Rust.
Tuples rūsā
Korpusa datu struktūra ļauj grupēt vairāk nekā vienu vērtību vienā saliktā vērtībā. Šīm vērtībām var būt viens vai dažādi veidi. Korekcijas var deklarēt, ierakstot tās kā ar komatu atdalītu vērtību sarakstu, ko ieskauj iekavās.
Tālāk ir norādīts, kā jūs varat deklarēt korešu ar 32 bitu veseliem skaitļiem, virknēm un float64 vērtībām.
ļaut tup: (i32, &str, f64) = (500, "Sveiki", 3.14);
Korpusiem ir fiksēts garums, un jūs varat tos izmantot, lai atgrieztu vairākas vērtības no funkcijas vai nodotu vairākas vērtības funkcijām kā vienu argumentu.
Varat piekļūt atsevišķiem kortedža elementiem, to iznīcinot, izmantojot paraugu saskaņošanu, vai tieši piekļūstot atsevišķiem elementiem, izmantojot punktu (.) sintaksi un indeksu.
Lūk, kā varat piekļūt atsevišķiem struktūras elementiem, izmantojot modeļu saskaņošanu.
ļaut mans_kopa = (10, "Sveika pasaule!", viltus);ļaut (x, y, z) = mans_korpuss;
println!("Pirmais elements ir: {}", x);
println!("Otrais elements ir: {}", y);
println!("Trešais elements ir: {}", z);
Lūk, kā varat piekļūt atsevišķiem elementiem, izmantojot punktu apzīmējumu.
ļaut mans_kopa = (10, "Sveika pasaule!", viltus);
println!("Thevispirmselementsir: {}", mans_kopa.0);
println!("Theotraiselementsir: {}", mans_kopa.1);
println!("Thetrešaiselementsir: {}", mans_kopa.2);
Korpusi ir ļoti noderīgi, grupējot saistītos datus vienā vērtībā. Tie var arī uzlabot jūsu koda lasāmību, ja tos izmantojat taupīgi.
Masīvi rūsā
Masīvs ir tāda paša veida elementu kopums ar fiksētu garumu. Jūs rakstāt Rust masīvus kā vērtību sarakstu kvadrātiekavās, atdalot tos ar komatiem.
Lūk, kā Rust var deklarēt masīvus:
ļaut arr = [1, 2, 3, 4, 5];
Jūs nevarat mainīt elementu skaitu masīvā, kad tas ir deklarēts, taču varat piekļūt atsevišķiem masīva elementiem, tos modificēt un manipulēt ar tiem, izmantojot indeksēšanu.
ļaut mut my_array = [1, 2, 3, 4, 5];// Piekļuve elementiem
println!("Thevispirmselementsir: {}", mans_masīvs[0]);// Elementu modificēšana
mans_masīvs[0] = 100;
println!("Thevispirmselementspēcmodifikācijuir: {}", mans_masīvs[0]);// Cilpas pārvietošana pa masīvu un manipulēšana ar elementiem
priekšiiekšā 0..my_masīvs.len() {
mans_masīvs[i] *= 2;
}
// masīva drukāšana
println!("Masīvs pēc manipulācijas: {:?}", mans_masīvs);
Rūsas masīvi ir glabājas uz kaudzes un tiem ir blakus esošas atmiņas sadalījums, tāpēc piekļuve masīva elementiem ir ātra un efektīva. Tas padara masīvus piemērotus situācijām, kad jums ir jāsaglabā un jāapstrādā daudzi elementi.
Darbs ar rūsas šķēlītēm
Šķēle ir datu struktūra, kas ļauj atsaukties uz blakus esošo elementu secību kolekcijā. Šķēles apzīmē ar &[T] tips, kur T ir šķēlumā saglabāto elementu veids.
fn galvenais(){
// deklarēt masīvu
ļaut mans_masīvs = [1, 2, 3, 4, 5];// izveido šķēli no masīva
ļaut my_slice = &mans_masīvs[1..3];
// izdrukā šķēli
println!("Šķēle: {:?}", my_slice);
}
Ievērojiet, kā diapazona sintakse, .., izvelk daļu no masīva, izmantojot sākuma indeksu un indeksu, kas ir par vienu lielāku par beigas:
Šķēles ir dinamiskas, tāpēc Rust var noteikt to garumu izpildes laikā. Varat arī nodot šķēles kā argumentus funkcijām bez kaudzes piešķiršanas.
Virkņu operācijām un datu apakškopu nodošanai funkcijām parasti izmantosiet šķēles. Tie ir spēcīgs un efektīvs rīks Rust kolekciju pārvaldībai, nodrošinot elastīgāku alternatīvu masīviem.
Rustā varat izveidot ar WebAssembly darbināmas priekšgala tīmekļa lietojumprogrammas
Zināšanas par datu veidiem ir ļoti svarīgas jūsu Rust ceļojumam, jo jūs tos izmantosit lielākajai daļai darbību, veidojot lietojumprogrammas.
WebAssembly ir zema līmeņa binārais formāts, kas darbojas modernās tīmekļa pārlūkprogrammās ar gandrīz vietējo veiktspēju. Tas ļauj rakstīt kodu daudzās dažādās valodās un pārsūtīt to uz WebAssembly.
WebAssembly tiek pieņemts, izmantojot Rust. Ir daudz ietvaru, piemēram, Yew, Sycamore un Seed, ko varat izmantot, lai ar Rust izveidotu ar WebAssembly darbināmus priekšgalus.
