Rust er et statisk skrevet moderne programmeringsspråk designet for ytelse, pålitelighet og sikkerhet. Som i andre statisk-type språk, erklærer du Rust-datatyper på kompileringstidspunktet. Dette gjør det lettere å fange opp typefeil før du kjører koden.
Rust tilbyr skalarer, sammensatte, referansetyper, strukturer, enums og strenger. Typeslutningen gir funksjonalitet for å skrive kortfattet kode samtidig som sikkerheten til et statisk skrevet språk opprettholdes.
Heltall i Rust
Rust gir signerte og usignerte heltallstyper klassifisert basert på antall biter. De signerte heltallstypene er i8, i16, i32, og i64 som representerer henholdsvis 8-bits, 16-biters, 32-biters og 64-biters fortegnede heltall. Den støtter også usignerte heltallstyper u8, u16, u32, og u64, som representerer 8-biters, 16-biters, 32-biters og 64-biters usignerte heltall.
// signerte heltall
la a: i8 = -10;
la b: i16 = -2048;
la c: i32 = -2147483648;
la d: i64 = -9223372036854775808;
// usignerte heltall
la e: u8 = 255;
la f: u16 = 65535;
la g: u32 = 4294967295;
la h: u64 = 18446744073709551615;
Rust bruker i32 type for heltallsliteral som standard.
Rust flytepunkttyper
Rust gir f32 og f64 som flyttalltyper som representerer enkeltpresisjons- og dobbelpresisjonsflyttall. De f32 type bruker 32 biter til å lagre verdier, og f64 type bruker 64 biter.
Flytende tall i Rust følger IEEE 754-standarden for flytende aritmetikk.
la a = 3.14159265358979323_f32;
la b = 2.718281828459045235_f64;
Bruker Rust Booleans
Rust gir en bool type for å representere ekte eller falsk verdier. Boolere brukes ofte i betingede og kontrollflytutsagn for programbeslutninger.
la variabel_1: bool = ekte;
la variabel_2: bool = falsk;
Du kan sammenligne boolske verdier med likhetsoperatoren, ==, og ulikhetsoperatøren, !=. Rust definerer ikke sammenligningsoperatørene, , <=, og >=, for bool verdier.
la variabel_1: bool = ekte;
la variabel_2: bool = falsk;
if variabel_1 == variabel_2 {
println!("variabel_1 er lik variabel_2");
} ellershvis variabel_1 != variabel_2 {
println!("variabel_1 er ikke lik variabel_2");
}
Char Type
Rusten røye type representerer en enkelt Unicode-skalarverdi som kan representere et hvilket som helst tegn i Unicode-standarden. Du kan spesifisere en røye verdi ved å bruke enkle anførselstegn.
// Erklære en char-verdi
la c = 'en';
De røye type er nyttig for å jobbe med emojier i Rust.
Tuples i Rust
Tuppeldatastrukturen lar deg gruppere mer enn én verdi i en enkelt sammensatt verdi. Disse verdiene kan ha samme type eller forskjellige typer. Du kan erklære tupler ved å skrive dem som en kommadelt liste over verdier omgitt av parenteser.
Slik kan du deklarere en tuppel med 32-biters heltall, strenger og float64-verdier.
la tup: (i32, &str, f64) = (500, "Hallo", 3.14);
Tupler har en fast lengde, og du kan bruke dem til å returnere flere verdier fra en funksjon eller sende flere verdier til funksjoner som et enkelt argument.
Du kan få tilgang til individuelle elementer i en tuppel ved å destrukturere den ved å bruke mønstertilpasning eller direkte tilgang til individuelle elementer ved å bruke punkt (.)-syntaks og en indeks.
Slik kan du få tilgang til individuelle elementer i en struktur ved å bruke mønstertilpasning:
la min_tuppel = (10, "Hei Verden!", falsk);la (x, y, z) = min_tuppel;
println!("Det første elementet er: {}", x);
println!("Det andre elementet er: {}", y);
println!("Det tredje elementet er: {}", z);
Slik kan du få tilgang til individuelle elementer ved hjelp av punktnotasjon:
la min_tuppel = (10, "Hei Verden!", falsk);
println!("Deførstelementer: {}", min_tuppel.0);
println!("Desekundelementer: {}", min_tuppel.1);
println!("Detredjeelementer: {}", min_tuppel.2);
Tuples er veldig nyttige når du grupperer relaterte data i en enkelt verdi. De kan også forbedre lesbarheten til koden din hvis du bruker dem sparsomt.
Arrays i Rust
En matrise er en samling av elementer av samme type med en fast lengde. Du skriver Rust-matriser som en liste med verdier med firkantede parenteser, atskilt med komma.
Slik kan du deklarere matriser i Rust:
la arr = [1, 2, 3, 4, 5];
Du kan ikke endre antall elementer i en matrise når du har erklært den, men du kan få tilgang til, modifisere og manipulere individuelle elementer i en matrise ved hjelp av indeksering.
la mut my_array = [1, 2, 3, 4, 5];// Tilgang til elementer
println!("Deførstelementer: {}", my_array[0]);// Modifisering av elementer
min_matrise[0] = 100;
println!("Deførstelementettermodifikasjoner: {}", my_array[0]);// Sløyfe over en matrise og manipulere elementer
tilJegi 0..my_array.len() {
min_array[i] *= 2;
}
// skrive ut matrisen
println!("Matrisen etter manipulering: {:?}", my_array);
Rust Arrays er lagret på stabelen og har en sammenhengende minneallokering, så tilgang til elementer i en matrise er rask og effektiv. Dette gjør arrays egnet for situasjoner der du trenger å lagre og behandle mange elementer.
Arbeid med rustskiver
En skive er en datastruktur som gjør det mulig å referere til en sammenhengende sekvens av elementer i en samling. Skiver er representert av &[T] type, der T er typen elementer som er lagret i skiven.
fn hoved-(){
// erklære en matrise
la my_array = [1, 2, 3, 4, 5];// lag en skive fra matrisen
la my_slice = &my_array[1..3];
// skriv ut skiven
println!("Skive: {:?}", my_slice);
}
Legg merke til hvordan områdesyntaksen, .., trekker ut et stykke fra en matrise ved å bruke startindeksen og en indeks som er en større enn slutten:
Skiver er dynamiske, så Rust kan bestemme lengden deres under kjøring. Du kan også sende skiver som argumenter til funksjoner uten å trenge heap-allokering.
Du vil vanligvis bruke stykker for strengoperasjoner og for å sende delsett av data til funksjoner. De er et kraftig og effektivt verktøy for å administrere samlinger i Rust, og gir et mer fleksibelt alternativ til arrays.
Du kan bygge WebAssembly-drevne frontend-webapper i Rust
Kunnskap om datatyper er avgjørende for Rust-reisen din, siden du vil bruke dem til de fleste operasjoner mens du bygger applikasjoner.
WebAssembly er et lavt nivå binært format som kjører på moderne nettlesere, med nesten opprinnelig ytelse. Den lar deg skrive kode på mange forskjellige språk og transpilere den til WebAssembly.
WebAssembly blir tatt i bruk gjennom Rust. Det er mange rammeverk som Yew, Sycamore og Seed som du kan bruke til å bygge WebAssembly-drevne frontends med Rust.