Rust je staticky typovaný moderní programovací jazyk navržený pro výkon, spolehlivost a bezpečnost. Stejně jako v jiných jazycích se statickým typem deklarujete datové typy Rust v době kompilace. To usnadňuje zachycení chyb typu před spuštěním kódu.
Rust nabízí skalární, složené, referenční typy, struktury, výčty a řetězce. Jeho odvození typu poskytuje funkce pro psaní stručného kódu při zachování bezpečnosti staticky psaného jazyka.
Celá čísla v Rustu
Rust poskytuje celočíselné typy se znaménkem a bez znaménka klasifikované na základě počtu bitů. Typy celých čísel se znaménkem jsou i8, i16, i32, a i64 představující 8bitová, 16bitová, 32bitová a 64bitová celá čísla se znaménkem. Podporuje také celočíselné typy bez znaménka u8, u16, u32, a u64, představující 8bitová, 16bitová, 32bitová a 64bitová celá čísla bez znaménka.
// celá čísla se znaménkem
nechat a: i8 = -10;
nechat b: i16 = -2048;
nechat c: i32 = -2147483648;
nechat d: i64 = -9223372036854775808;
// celá čísla bez znaménka
nechat e: u8 = 255;
nechat f: u16 = 65535;
nechat g: u32 = 4294967295;
nechat h: u64 = 18446744073709551615;
Rust používá i32 typ pro celočíselné literály ve výchozím nastavení.
Rez Typy s plovoucí desetinnou čárkou
Rez poskytuje f32 a f64 jako typy s plovoucí desetinnou čárkou, které představují čísla s plovoucí desetinnou čárkou s jednoduchou a dvojitou přesností. The f32 typ používá 32 bitů k uložení hodnot a f64 typ používá 64 bitů.
Čísla s plovoucí desetinnou čárkou v Rustu se řídí standardem IEEE 754 pro aritmetiku s plovoucí desetinnou čárkou.
nechat a = 3.14159265358979323_f32;
nechat b = 2.718281828459045235_f64;
Použití Rust Booleans
Rez poskytuje a bool typ reprezentovat skutečný nebo Nepravdivé hodnoty. Booleany se často používají v podmíněných a řídicích příkazech pro rozhodování o programu.
nechat proměnná_1: bool = skutečný;
nechat proměnná_2: bool = Nepravdivé;
Booleovské hodnoty můžete porovnat s operátorem rovnosti, ==a operátor nerovnosti, !=. Rust nedefinuje srovnávací operátory, , <=, a >=, pro bool hodnoty.
nechat proměnná_1: bool = skutečný;
nechat proměnná_2: bool = Nepravdivé;
if proměnná_1 == proměnná_2 {
println!("proměnná_1 se rovná proměnné_2");
} jiný-li proměnná_1 != proměnná_2 {
println!("proměnná_1 se nerovná proměnná_2");
}
Typ znaku
Rust char typ představuje jedinou skalární hodnotu Unicode, která může představovat jakýkoli znak v standard Unicode. Můžete zadat a char hodnotu pomocí jednoduchých uvozovek.
// Deklarace hodnoty znaku
nechat c = 'A';
The char typ je užitečný pro práci s emotikony v Rust.
N-tice v rzi
Struktura dat n-tice umožňuje seskupit více než jednu hodnotu do jedné složené hodnoty. Tyto hodnoty mohou mít stejný typ nebo různé typy. N-tice můžete deklarovat tak, že je zapíšete jako seznam hodnot oddělených čárkami v závorkách.
Zde je návod, jak můžete deklarovat n-tici s 32bitovými celými čísly, řetězci a hodnotami float64.
nechat tup: (i32, &str, f64) = (500, "Ahoj", 3.14);
N-tice mají pevnou délku a můžete je použít k vrácení více hodnot z funkce nebo k předání více hodnot funkcím jako jeden argument.
K jednotlivým prvkům n-tice můžete přistupovat jejich destrukcí pomocí porovnávání vzorů nebo přímým přístupem k jednotlivým prvkům pomocí syntaxe tečky (.) a indexu.
Zde je návod, jak můžete přistupovat k jednotlivým prvkům struktury pomocí porovnávání vzorů:
nechat moje_tuple = (10, "Ahoj světe!", Nepravdivé);nechat (x, y, z) = moje_ntice;
println!("První prvek je: {}", X);
println!("Druhý prvek je: {}", y);
println!("Třetí prvek je: {}", z);
Zde je návod, jak můžete přistupovat k jednotlivým prvkům pomocí tečkové notace:
nechat moje_tuple = (10, "Ahoj světe!", Nepravdivé);
println!("ThePrvníživelje: {}", moje_tuple.0);
println!("Thedruhýživelje: {}", moje_tuple.1);
println!("TheTřetíživelje: {}", moje_tuple.2);
N-tice jsou velmi užitečné při seskupování souvisejících dat do jedné hodnoty. Mohou také zlepšit čitelnost vašeho kódu, pokud je používáte šetrně.
Pole v Rustu
Pole je kolekce prvků stejného typu s pevnou délkou. Pole Rust zapisujete jako seznam hodnot v hranatých závorkách oddělených čárkami.
Zde je návod, jak můžete deklarovat pole v Rustu:
nechat arr = [1, 2, 3, 4, 5];
Jakmile jste pole deklarovali, nemůžete změnit počet prvků v poli, ale můžete přistupovat k jednotlivým prvkům pole, upravovat je a manipulovat s nimi pomocí indexování.
nechat mut my_array = [1, 2, 3, 4, 5];// Přístup k prvkům
println!("ThePrvníživelje: {}", moje_pole[0]);// Úprava prvků
moje_pole[0] = 100;
println!("ThePrvníživelpomodifikaceje: {}", moje_pole[0]);// Opakování pole a manipulace s prvky
proiv 0..my_array.len() {
moje_pole[i] *= 2;
}
// tisk pole
println!("Pole po manipulaci: {:?}", moje_pole);
Rust Arrays jsou uloženy na stohu a mají souvislou alokaci paměti, takže přístup k prvkům pole je rychlý a efektivní. Díky tomu jsou pole vhodná pro situace, kdy potřebujete uložit a zpracovat mnoho prvků.
Práce S Plátky rzi
Řez je datová struktura, která umožňuje odkazovat na souvislou sekvenci prvků v kolekci. Řezy jsou reprezentovány &[T] typ, kde T je typ prvků uložených v řezu.
fn hlavní(){
// deklarovat pole
nechat moje_pole = [1, 2, 3, 4, 5];// vytvořte řez z pole
nechat můj_slice = &moje_pole[1..3];
// tisk řezu
println!("Plátek: {:?}", můj_slice);
}
Všimněte si, jak syntaxe rozsahu, .., extrahuje řez z pole pomocí počátečního indexu a indexu o jeden většího než je konec:
Řezy jsou dynamické, takže Rust může určit jejich délku za běhu. Řezy můžete také předávat jako argumenty funkcím, aniž byste potřebovali alokaci haldy.
Řezy budete běžně používat pro operace s řetězci a pro předávání podmnožin dat funkcím. Jsou výkonným a efektivním nástrojem pro správu kolekcí v Rustu a poskytují flexibilnější alternativu k polím.
V Rustu můžete vytvářet frontendové webové aplikace založené na WebAssembly
Znalost datových typů je pro vaši cestu Rustem klíčová, protože je využijete pro většinu operací při vytváření aplikací.
WebAssembly je nízkoúrovňový binární formát, který běží na moderních webových prohlížečích s téměř nativním výkonem. Umožňuje vám psát kód v mnoha různých jazycích a překládat jej do WebAssembly.
WebAssembly získává přijetí prostřednictvím Rust. Existuje mnoho frameworků jako Yew, Sycamore a Seed, které můžete použít k sestavení frontendů založených na WebAssembly s Rustem.
