Kaltaisesi lukijat auttavat tukemaan MUO: ta. Kun teet ostoksen käyttämällä sivustollamme olevia linkkejä, voimme ansaita kumppanipalkkion. Lue lisää.

Rust on staattisesti kirjoitettu moderni ohjelmointikieli, joka on suunniteltu suorituskykyyn, luotettavuuteen ja turvallisuuteen. Kuten muissakin staattisesti kirjoitetuissa kielissä, Rust-tietotyypit ilmoitat käännöshetkellä. Tämä helpottaa tyyppivirheiden havaitsemista ennen koodin suorittamista.

Rust tarjoaa skalaari-, yhdiste-, viitetyyppejä, rakenteita, enumeja ja merkkijonoja. Sen tyyppipäätelmä tarjoaa toiminnot tiiviin koodin kirjoittamiseen säilyttäen samalla staattisesti kirjoitetun kielen turvallisuuden.

Kokonaisluvut ruosteessa

Rust tarjoaa etumerkillisiä ja etumerkittömiä kokonaislukutyyppejä, jotka on luokiteltu bittien määrän perusteella. Etumerkilliset kokonaislukutyypit ovat i8, i16, i32, ja i64 edustavat 8-bittisiä, 16-bittisiä, 32-bittisiä ja 64-bittisiä etumerkillisiä kokonaislukuja. Se tukee myös etumerkittömiä kokonaislukutyyppejä

instagram viewer
u8, u16, u32, ja u64, jotka edustavat 8-bittisiä, 16-bittisiä, 32-bittisiä ja 64-bittisiä etumerkittömiä kokonaislukuja.

// etumerkilliset kokonaisluvut
antaa a: i8 = -10;
antaa b: i16 = -2048;
antaa c: i32 = -2147483648;
antaa d: i64 = -9223372036854775808;
// etumerkittömät kokonaisluvut
antaa e: u8 = 255;
antaa f: u16 = 65535;
antaa g: u32 = 4294967295;
antaa h: u64 = 18446744073709551615;

Rust käyttää i32 kirjoita oletuksena kokonaislukuliteraaleille.

Ruosteen liukulukutyypit

Ruoste tarjoaa f32 ja f64 liukulukutyypeinä, jotka edustavat yhden ja kaksinkertaisen tarkkuuden liukulukuja. The f32 Type käyttää 32 bittiä arvojen tallentamiseen, ja f64 tyyppi käyttää 64 bittiä.

Rustissa olevat liukulukuluvut noudattavat IEEE 754 -standardia liukulukuaritmetiikkaa varten.

antaa a = 3.14159265358979323_f32;
antaa b = 2.718281828459045235_f64;

Rust Booleansin käyttö

Rust tarjoaa a bool tyyppi edustaa totta tai väärä arvot. Booleaneja käytetään usein ehdollisissa ja ohjausvuolausekkeissa ohjelman päätöksenteossa.

antaa muuttuja_1: bool = totta;
antaa muuttuja_2: bool = väärä;

Voit verrata loogisia arvoja yhtäläisyysoperaattorilla, ==ja epätasa-arvooperaattori, !=. Rust ei määrittele vertailuoperaattoreita, , <=, ja >=, varten bool arvot.

antaa muuttuja_1: bool = totta;
antaa muuttuja_2: bool = väärä;
if muuttuja_1 == muuttuja_2 {
 println!("muuttuja_1 on yhtä suuri kuin muuttuja_2");
} muujos muuttuja_1 != muuttuja_2 {
 println!("muuttuja_1 ei ole sama kuin muuttuja_2");
}

Merkin tyyppi

Ruoste hiiltyä Type edustaa yhtä Unicode-skalaariarvoa, joka voi edustaa mitä tahansa merkkiä Unicode-standardi. Voit määrittää a hiiltyä arvo yksittäisillä lainausmerkeillä.

// Merkin arvon ilmoittaminen
antaa c = 'a';

The hiiltyä tyyppi on hyödyllinen emojien kanssa työskentelemiseen Rustissa.

Tuples ruosteessa

Tuple-tietorakenteen avulla voit ryhmitellä useamman kuin yhden arvon yhdeksi yhdistelmäarvoksi. Näillä arvoilla voi olla samaa tyyppiä tai eri tyyppejä. Voit ilmoittaa monikot kirjoittamalla ne pilkuilla eroteltuna arvoluettelona suluissa.

Näin voit ilmoittaa monikon, jossa on 32-bittisiä kokonaislukuja, merkkijonoja ja float64-arvoja.

antaa tup: (i32, &str, f64) = (500, "Hei", 3.14);

Tupleilla on kiinteä pituus, ja voit käyttää niitä palauttamaan useita arvoja funktiosta tai välittämään useita arvoja funktioille yhtenä argumenttina.

Voit käyttää monikon yksittäisiä elementtejä tuhoamalla sen rakennetta käyttämällä mallinsovitusta tai suoraan yksittäisiin elementteihin käyttämällä pisteen (.) syntaksia ja indeksiä.

Näin pääset käsiksi rakenteen yksittäisiin elementteihin kuvion täsmäyttämisen avulla:

antaa my_tuple = (10, "Hei maailma!", väärä);
antaa (x, y, z) = oma_tuple;
println!("Ensimmäinen elementti on: {}", x);
println!("Toinen elementti on: {}", y);
println!("Kolmas elementti on: {}", z);

Näin voit käyttää yksittäisiä elementtejä käyttämällä pistemerkintää:

antaa my_tuple = (10, "Hei maailma!", väärä);
println!("TheensimmäinenelementtiOn: {}", my_tuple.0);
println!("ThetoinenelementtiOn: {}", my_tuple.1);
println!("ThekolmaselementtiOn: {}", my_tuple.2);

Tuplet ovat erittäin hyödyllisiä ryhmitettäessä toisiinsa liittyviä tietoja yhdeksi arvoksi. Ne voivat myös parantaa koodisi luettavuutta, jos käytät niitä säästeliäästi.

Arrays ruosteessa

Taulukko on kokoelma samantyyppisiä elementtejä, joilla on kiinteä pituus. Kirjoitat Rust-taulukot hakasulkeisiin arvoluetteloihin, jotka erotetaan pilkuilla.

Näin voit ilmoittaa taulukoita Rustissa:

antaa arr = [1, 2, 3, 4, 5];

Et voi muuttaa taulukon elementtien määrää, kun olet ilmoittanut sen, mutta voit käyttää, muokata ja käsitellä taulukon yksittäisiä elementtejä indeksoinnin avulla.

antaa mut my_array = [1, 2, 3, 4, 5];
// Elementtien käyttö
println!("TheensimmäinenelementtiOn: {}", my_array[0]);


// Elementtien muokkaaminen
oma_taulukko[0] = 100;
println!("TheensimmäinenelementtijälkeenmuutosOn: {}", my_array[0]);


// Silmukka taulukon yli ja elementtien käsittely
vartenisisään 0..my_array.len() {
 oma_taulukko[i] *= 2;
}
// taulukon tulostaminen
println!("Matriisi käsittelyn jälkeen: {:?}", oma_taulukko);

Rust Arrays ovat varastoitu pinoon ja niillä on jatkuva muistivaraus, joten taulukon elementtien käyttö on nopeaa ja tehokasta. Tämä tekee taulukoista sopivia tilanteisiin, joissa sinun on tallennettava ja prosessoitava monia elementtejä.

Työskentely ruosteviipaleiden kanssa

Viipale on tietorakenne, jonka avulla voidaan viitata kokoelman vierekkäisiin elementteihin. Viipaleita edustaa &[T] tyyppi, jossa T on viipaleeseen tallennettujen elementtien tyyppi.

fn pää(){
// julistaa taulukon
antaa my_array = [1, 2, 3, 4, 5];
// luo lohkon taulukosta
antaa my_slice = &my_array[1..3];
// tulosta siivu
 println!("Slice: {:?}", my_slice);
}

Huomaa, kuinka alueen syntaksi, .., poimii osan taulukosta käyttämällä aloitusindeksiä ja loppua yhtä suurempaa indeksiä:

Leikkeet ovat dynaamisia, joten Rust voi määrittää niiden pituuden ajon aikana. Voit myös välittää viipaleita argumenteina funktioille ilman, että tarvitset keon allokointia.

Käytät yleensä viipaleita merkkijonotoimintoihin ja tietojen osajoukkojen välittämiseen funktioille. Ne ovat tehokas ja tehokas työkalu kokoelmien hallintaan Rustissa, mikä tarjoaa joustavamman vaihtoehdon taulukoille.

Voit rakentaa WebAssembly-käyttöisiä käyttöliittymäverkkosovelluksia Rustissa

Tietotyyppien tuntemus on avainasemassa Rust-matkallasi, koska käytät niitä useimmissa sovellusten rakentamisen toiminnoissa.

WebAssembly on matalan tason binaarimuoto, joka toimii nykyaikaisissa verkkoselaimissa lähes alkuperäisellä suorituskyvyllä. Sen avulla voit kirjoittaa koodia useilla eri kielillä ja siirtää sen WebAssemblyyn.

WebAssembly on saamassa käyttöönsä Rustin kautta. On olemassa monia kehyksiä, kuten Yew, Sycamore ja Seed, joita voit käyttää WebAssembly-käyttöisten käyttöliittymien rakentamiseen Rustilla.