Rust är ett statiskt format modernt programmeringsspråk designat för prestanda, tillförlitlighet och säkerhet. Som i andra statiskt skrivna språk, deklarerar du Rust-datatyper vid kompilering. Detta gör det lättare att fånga typfel innan du kör din kod.
Rust erbjuder skalära, sammansatta, referenstyper, strukturer, enums och strängar. Dess typinferens ger funktionalitet för att skriva kortfattad kod samtidigt som säkerheten för ett statiskt skrivet språk bibehålls.
Heltal i Rust
Rust tillhandahåller signerade och osignerade heltalstyper som klassificeras baserat på antalet bitar. De signerade heltalstyperna är i8, i16, i32, och i64 representerar 8-bitars, 16-bitars, 32-bitars respektive 64-bitars signerade heltal. Den stöder också osignerade heltalstyper u8, u16, u32, och u64, representerar 8-bitars, 16-bitars, 32-bitars och 64-bitars heltal utan tecken.
// undertecknade heltal
låta a: i8 = -10;
låta b: i16 = -2048;
låta c: i32 = -2147483648;
låta d: i64 = -9223372036854775808;
// heltal utan tecken
låta e: u8 = 255;
låta f: u16 = 65535;
låta g: u32 = 4294967295;
låta h: u64 = 18446744073709551615;
Rust använder i32 typ för heltalsliteral som standard.
Rost flytpunktstyper
Rost ger f32 och f64 som flyttalstyper som representerar enkelprecisions- och dubbelprecisionsflyttal. De f32 typ använder 32 bitar för att lagra värden, och f64 typ använder 64 bitar.
Flyttal i Rust följer IEEE 754-standarden för aritmetik med flyttal.
låta a = 3.14159265358979323_f32;
låta b = 2.718281828459045235_f64;
Använder Rust Booleans
Rost ger en bool typ att representera Sann eller falsk värden. Booleans används ofta i villkors- och kontrollflödessatser för programbeslut.
låta variabel_1: bool = Sann;
låta variabel_2: bool = falsk;
Du kan jämföra booleska värden med jämlikhetsoperatorn, ==, och ojämlikhetsoperatören, !=. Rust definierar inte jämförelseoperatorerna, , <=, och >=, för bool värden.
låta variabel_1: bool = Sann;
låta variabel_2: bool = falsk;
om variabel_1 == variabel_2 {
println!("variabel_1 är lika med variabel_2");
} annanom variabel_1 != variabel_2 {
println!("variabel_1 är inte lika med variabel_2");
}
Typ av röding
Rosten röding typ representerar ett enda skalärt Unicode-värde som kan representera vilket tecken som helst i Unicode-standarden. Du kan ange en röding värde med enstaka citattecken.
// Deklarerar ett char-värde
låta c = 'a';
De röding typ är användbart för att arbeta med emojis i Rust.
Tuplar i rost
Tupeldatastrukturen låter dig gruppera mer än ett värde i ett enda sammansatt värde. Dessa värden kan ha samma typ eller olika typer. Du kan deklarera tupler genom att skriva dem som en kommaseparerad lista med värden omgiven av parenteser.
Så här kan du deklarera en tupel med 32-bitars heltal, strängar och float64-värden.
låta tup: (i32, &str, f64) = (500, "Hallå", 3.14);
Tuples har en fast längd, och du kan använda dem för att returnera flera värden från en funktion eller skicka flera värden till funktioner som ett enda argument.
Du kan komma åt enskilda element i en tupel genom att destrukturera den med mönstermatchning eller direkt komma åt enskilda element med hjälp av punkt (.)-syntax och ett index.
Så här kan du komma åt enskilda element i en struktur med hjälp av mönstermatchning:
låta my_tuple = (10, "Hej världen!", falsk);låta (x, y, z) = min_tupel;
println!("Det första elementet är: {}", x);
println!("Det andra elementet är: {}"y);
println!("Det tredje elementet är: {}"z);
Så här kan du komma åt enskilda element med hjälp av punktnotation:
låta my_tuple = (10, "Hej världen!", falsk);
println!("Deförstelementär: {}", min_tupel.0);
println!("Deandraelementär: {}", min_tupel.1);
println!("Detredjeelementär: {}", min_tupel.2);
Tuples är mycket användbara när du grupperar relaterade data till ett enda värde. De kan också förbättra läsbarheten för din kod om du använder dem sparsamt.
Arrayer i Rust
En array är en samling element av samma typ med en fast längd. Du skriver Rust-matriser som en lista med värden inom hakparenteser, separerade med kommatecken.
Så här kan du deklarera arrayer i Rust:
låta arr = [1, 2, 3, 4, 5];
Du kan inte ändra antalet element i en array när du väl har deklarerat den, men du kan komma åt, ändra och manipulera enskilda element i en array med hjälp av indexering.
låta mut my_array = [1, 2, 3, 4, 5];// Åtkomst till element
println!("Deförstelementär: {}", min_array[0]);// Ändring av element
min_array[0] = 100;
println!("Deförstelementeftermodifieringär: {}", min_array[0]);// Slinga över en array och manipulera element
förii 0..my_array.len() {
min_array[i] *= 2;
}
// skriva ut arrayen
println!("Arrayen efter manipulation: {:?}", my_array);
Rust Arrays är lagras på högen och har en sammanhängande minnesallokering, så att åtkomst till element i en array är snabb och effektiv. Detta gör arrayer lämpliga för situationer där du behöver lagra och bearbeta många element.
Arbeta med rostskivor
En skiva är en datastruktur som gör det möjligt att referera till en sammanhängande sekvens av element i en samling. Skivor representeras av &[T] typ, där T är den typ av element som lagras i segmentet.
fn huvud(){
// deklarera en array
låta my_array = [1, 2, 3, 4, 5];// skapa en skiva från arrayen
låta my_slice = &my_array[1..3];
// skriv ut skivan
println!("Slice: {:?}", my_slice);
}
Lägg märke till hur intervallsyntaxen, .., extraherar en skiva från en array med hjälp av startindexet och ett index som är ett större än slutet:
Skivor är dynamiska, så Rust kan bestämma deras längd under körning. Du kan också skicka segment som argument till funktioner utan att behöva tilldela heap.
Du kommer vanligtvis att använda segment för strängoperationer och för att skicka delmängder av data till funktioner. De är ett kraftfullt och effektivt verktyg för att hantera samlingar i Rust, vilket ger ett mer flexibelt alternativ till arrayer.
Du kan bygga WebAssembly-drivna frontend-webbappar i Rust
Kunskap om datatyper är avgörande för din Rust-resa eftersom du kommer att använda dem för de flesta operationer när du bygger applikationer.
WebAssembly är ett binärt format på låg nivå som körs på moderna webbläsare, med nästan inbyggd prestanda. Den låter dig skriva kod på många olika språk och överföra den till WebAssembly.
WebAssembly blir adopterad genom Rust. Det finns många ramverk som Yew, Sycamore och Seed som du kan använda för att bygga WebAssembly-drivna frontends med Rust.
