Rust er et statisk skrevet moderne programmeringssprog designet til ydeevne, pålidelighed og sikkerhed. Som i andre statisk-typede sprog, erklærer du Rust-datatyper på kompileringstidspunktet. Dette gør det nemmere at fange typefejl, før du kører din kode.
Rust tilbyder skalar, sammensatte, referencetyper, strukturer, enums og strenge. Dens typeinferens giver funktionalitet til at skrive kortfattet kode, samtidig med at sikkerheden ved et statisk skrevet sprog opretholdes.
Heltal i Rust
Rust giver signerede og usignerede heltalstyper klassificeret baseret på antallet af bits. De signerede heltalstyper er i8, i16, i32, og i64 repræsenterer henholdsvis 8-bit, 16-bit, 32-bit og 64-bit signerede heltal. Det understøtter også usignerede heltalstyper u8, u16, u32, og u64, der repræsenterer 8-bit, 16-bit, 32-bit og 64-bit heltal uden fortegn.
// signerede heltal
lade a: i8 = -10;
lade b: i16 = -2048;
lade c: i32 = -2147483648;
lade d: i64 = -9223372036854775808;
// heltal uden fortegn
lade e: u8 = 255;
lade f: u16 = 65535;
lade g: u32 = 4294967295;
lade h: u64 = 18446744073709551615;
Rust bruger i32 type for heltalsliteraler som standard.
Rust flydepunktstyper
Rust giver f32 og f64 som flydende komma-typer, der repræsenterer enkelt-præcision og dobbelt-præcision flydende tal. Det f32 type bruger 32 bit til at gemme værdier, og f64 type bruger 64 bit.
Flydende kommatal i Rust følger IEEE 754-standarden for flydende kommaaritmetik.
lade a = 3.14159265358979323_f32;
lade b = 2.718281828459045235_f64;
Brug af Rust Booleans
Rust giver en bool type at repræsentere rigtigt eller falsk værdier. Booleans bruges ofte i betingede og kontrol-flow-sætninger til programbeslutningstagning.
lade variabel_1: bool = rigtigt;
lade variabel_2: bool = falsk;
Du kan sammenligne booleske værdier med lighedsoperatoren, ==og ulighedsoperatøren, !=. Rust definerer ikke sammenligningsoperatørerne, , <=, og >=, til bool værdier.
lade variabel_1: bool = rigtigt;
lade variabel_2: bool = falsk;
hvis variabel_1 == variabel_2 {
println!("variabel_1 er lig med variabel_2");
} andethvis variabel_1 != variabel_2 {
println!("variabel_1 er ikke lig med variabel_2");
}
Char Type
Rusten char type repræsenterer en enkelt Unicode skalarværdi, der kan repræsentere et hvilket som helst tegn i Unicode-standarden. Du kan angive en char værdi ved hjælp af enkelte anførselstegn.
// Erklærer en char-værdi
lade c = 'en';
Det char type er nyttig til at arbejde med emojis i Rust.
Tuples i Rust
Tupeldatastrukturen lader dig gruppere mere end én værdi i en enkelt sammensat værdi. Disse værdier kan have samme type eller forskellige typer. Du kan erklære tupler ved at skrive dem som en kommasepareret liste over værdier omgivet af parenteser.
Her er hvordan du kan erklære en tupel med 32-bit heltal, strenge og float64 værdier.
lade tup: (i32, &str, f64) = (500, "Hej", 3.14);
Tuples har en fast længde, og du kan bruge dem til at returnere flere værdier fra en funktion eller sende flere værdier til funktioner som et enkelt argument.
Du kan få adgang til individuelle elementer i en tupel ved at destrukturere den ved hjælp af mønstermatchning eller direkte adgang til individuelle elementer ved hjælp af punkt (.) syntaks og et indeks.
Sådan kan du få adgang til individuelle elementer i en struktur ved hjælp af mønstermatchning:
lade my_tuple = (10, "Hej Verden!", falsk);lade (x, y, z) = min_tupel;
println!("Det første element er: {}", x);
println!("Det andet element er: {}"y);
println!("Det tredje element er: {}", z);
Sådan kan du få adgang til individuelle elementer ved hjælp af punktnotation:
lade my_tuple = (10, "Hej Verden!", falsk);
println!("Detførstelementer: {}", min_tupel.0);
println!("Detandenelementer: {}", min_tupel.1);
println!("Dettredjeelementer: {}", min_tupel.2);
Tuples er meget nyttige, når du grupperer relaterede data i en enkelt værdi. De kan også forbedre læsbarheden af din kode, hvis du bruger dem sparsomt.
Arrays i Rust
Et array er en samling af elementer af samme type med en fast længde. Du skriver Rust-arrays som en liste med værdier med firkantede parenteser, adskilt af kommaer.
Sådan kan du erklære arrays i Rust:
lade arr = [1, 2, 3, 4, 5];
Du kan ikke ændre antallet af elementer i et array, når du først har erklæret det, men du kan få adgang til, ændre og manipulere individuelle elementer i et array ved hjælp af indeksering.
lade mut mit_array = [1, 2, 3, 4, 5];// Adgang til elementer
println!("Detførstelementer: {}", mit_array[0]);// Ændring af elementer
mit_array[0] = 100;
println!("Detførstelementeftermodifikationer: {}", mit_array[0]);// Sløjfe over et array og manipulere elementer
tiljegi 0..mit_array.len() {
mit_array[i] *= 2;
}
// udskrivning af arrayet
println!("Arrayet efter manipulation: {:?}", mit_array);
Rust Arrays er gemt på stakken og har en sammenhængende hukommelsesallokering, så adgang til elementer i et array er hurtig og effektiv. Dette gør arrays velegnede til situationer, hvor du skal gemme og behandle mange elementer.
Arbejde med rustskiver
Et udsnit er en datastruktur, der gør det muligt at referere til en sammenhængende sekvens af elementer i en samling. Skiver er repræsenteret af &[T] type, hvor T er den type elementer, der er gemt i udsnittet.
fn vigtigste(){
// erklære et array
lade mit_array = [1, 2, 3, 4, 5];// opret et udsnit fra arrayet
lade mit_udsnit = &mit_array[1..3];
// udskriv skiven
println!("Udsnit: {:?}", my_slice);
}
Bemærk, hvordan områdesyntaksen, .., udtrækker et udsnit fra et array ved hjælp af startindekset og et indeks, der er en større end slutningen:
Skiver er dynamiske, så Rust kan bestemme deres længde under kørsel. Du kan også sende udsnit som argumenter til funktioner uden behov for heap-allokering.
Du vil almindeligvis bruge udsnit til strengoperationer og til at sende delmængder af data til funktioner. De er et kraftfuldt og effektivt værktøj til at administrere samlinger i Rust, hvilket giver et mere fleksibelt alternativ til arrays.
Du kan bygge WebAssembly-drevne frontend-webapps i rust
Kendskab til datatyper er afgørende for din Rust-rejse, da du vil bruge dem til de fleste operationer, mens du bygger applikationer.
WebAssembly er et binært format på lavt niveau, der kører på moderne webbrowsere med næsten oprindelig ydeevne. Det lader dig skrive kode på mange forskellige sprog og transpilere det til WebAssembly.
WebAssembly vinder adoption gennem Rust. Der er mange rammer som Yew, Sycamore og Seed, som du kan bruge til at bygge WebAssembly-drevne frontends med Rust.
