A Rust egy statikusan tipizált modern programozási nyelv, amelyet a teljesítmény, a megbízhatóság és a biztonság érdekében terveztek. Más statikusan begépelt nyelvekhez hasonlóan a Rust adattípusokat a fordításkor deklarálja. Ez megkönnyíti a típushibák észlelését a kód futtatása előtt.
A Rust skaláris, összetett, referenciatípusokat, struktúrákat, enumokat és karakterláncokat kínál. Típuskövetkeztetése funkcionalitást biztosít tömör kód írására, miközben megőrzi a statikusan tipizált nyelv biztonságát.
Integers in Rust
A Rust előjeles és előjel nélküli egész számokat biztosít a bitek száma alapján osztályozva. Az előjeles egész típusok a i8, i16, i32, és i64 8 bites, 16 bites, 32 bites, illetve 64 bites előjeles egész számokat képvisel. Támogatja az előjel nélküli egész típusokat is u8, u16, u32, és u64, amely 8 bites, 16 bites, 32 bites és 64 bites előjel nélküli egész számokat jelent.
// előjeles egész számok
hagyja a: i8 = -10;
hagyja b: i16 = -2048;
hagyja c: i32 = -2147483648;
hagyja d: i64 = -9223372036854775808;
// előjel nélküli egész számok
hagyja e: u8 = 255;
hagyja f: u16 = 65535;
hagyja g: u32 = 4294967295;
hagyja h: u64 = 18446744073709551615;
Rust használja a i32 írja be az egész literálokat alapértelmezés szerint.
Rozsda lebegőpontos típusai
A rozsda biztosítja f32 és f64 mint lebegőpontos típusok, amelyek egyszeres és kétszeres pontosságú lebegőpontos számokat képviselnek. A f32 típus 32 bitet használ az értékek tárolására, és a f64 típus 64 bitet használ.
A Rust lebegőpontos számok követik az IEEE 754 lebegőpontos aritmetikai szabványt.
hagyja a = 3.14159265358979323_f32;
hagyja b = 2.718281828459045235_f64;
Rust Booleans használata
A rozsda biztosítja a bool típust képviselni igaz vagy hamis értékeket. A logikai értékeket gyakran használják feltételes és vezérlőfolyamat-utasításokban a program döntéshozatalához.
hagyja változó_1: bool = igaz;
hagyja változó_2: bool = hamis;
Összehasonlíthatja a logikai értékeket az egyenlőség operátorral, ==és az egyenlőtlenség operátor, !=. A Rust nem határozza meg az összehasonlító operátorokat, , <=, és >=, for bool értékeket.
hagyja változó_1: bool = igaz;
hagyja változó_2: bool = hamis;
if változó_1 == változó_2 {
println!("változó_1 egyenlő a változó_2-vel");
} másha változó_1 != változó_2 {
println!("változó_1 nem egyenlő változó_2");
}
A Char típusa
A rozsda char type egyetlen Unicode skalárértéket jelent, amely bármely karaktert képviselhet az Unicode szabvány. Megadhatja a char érték egyedi idézőjelek használatával.
// Char érték deklarálása
hagyja c = "a";
A char típus hasznos az emojikkal való munka során Rustban.
Tuples in Rust
A sor adatstruktúra lehetővé teszi, hogy egynél több értéket csoportosítson egyetlen összetett értékbe. Ezek az értékek lehetnek azonos típusúak vagy eltérőek. A sorokat úgy deklarálhatja, hogy az értékek vesszővel elválasztott listájaként írja be őket zárójelek közé.
Így deklarálhat egy leírót 32 bites egész számokkal, karakterláncokkal és float64 értékekkel.
hagyja tup: (i32, &str, f64) = (500, "Helló", 3.14);
A sorok fix hosszúságúak, és segítségével több értéket is visszaadhat egy függvényből, vagy több értéket adhat át a függvényeknek egyetlen argumentumként.
A sor egyes elemeit úgy érheti el, hogy mintaillesztéssel destrukturálja, vagy közvetlenül elérheti az egyes elemeket pont (.) szintaxis és index segítségével.
A következőképpen érheti el a struktúra egyes elemeit a mintaillesztés segítségével:
hagyja my_tuple = (10, "Helló Világ!", hamis);hagyja (x, y, z) = saját_sor;
println!("Az első elem: {}", x);
println!("A második elem: {}", y);
println!("A harmadik elem: {}", z);
A következőképpen érheti el az egyes elemeket pontjelöléssel:
hagyja my_tuple = (10, "Helló Világ!", hamis);
println!("Aelsőelemvan: {}", my_tuple.0);
println!("Amásodikelemvan: {}", my_tuple.1);
println!("Aharmadikelemvan: {}", my_tuple.2);
A sorok nagyon hasznosak, ha a kapcsolódó adatokat egyetlen értékké csoportosítják. A kód olvashatóságát is javíthatják, ha takarékosan használja őket.
Tömbök rozsdában
A tömb azonos típusú, rögzített hosszúságú elemek gyűjteménye. A Rust tömböket szögletes zárójeles értéklistaként írod, vesszővel elválasztva.
Így deklarálhatja a tömböket Rustban:
hagyja arr = [1, 2, 3, 4, 5];
Egy tömb elemeinek száma nem módosítható, miután deklarálta, de indexeléssel elérheti, módosíthatja és manipulálhatja a tömb egyes elemeit.
hagyja mut my_array = [1, 2, 3, 4, 5];// Elemek elérése
println!("Aelsőelemvan: {}", my_array[0]);// Elemek módosítása
saját_tömb[0] = 100;
println!("Aelsőelemutánmódosításvan: {}", my_array[0]);// Hurkolás egy tömb felett és elemek manipulálása
számáraénban ben 0..my_array.len() {
saját_tömb[i] *= 2;
}
// a tömb kinyomtatása
println!("A tömb a manipuláció után: {:?}", my_tömb);
A rozsdatömbök azok raktáron tárolva és összefüggő memóriafoglalásuk van, így egy tömb elemeinek elérése gyors és hatékony. Ez alkalmassá teszi a tömböket olyan helyzetekre, amikor sok elemet kell tárolni és feldolgozni.
Munka rozsdaszeletekkel
A szelet egy olyan adatstruktúra, amely lehetővé teszi a hivatkozást egy gyűjtemény elemeinek összefüggő sorozatára. A szeleteket a &[T] típus, ahol T a szeletben tárolt elemek típusa.
fn fő-(){
// deklarál egy tömböt
hagyja my_array = [1, 2, 3, 4, 5];// szelet létrehozása a tömbből
hagyja my_slice = &saját_tömb[1..3];
// kinyomtatja a szeletet
println!("Slice: {:?}", my_slice);
}
Figyelje meg, hogy a tartomány szintaxisa, .., kivesz egy szeletet egy tömbből a kezdő index és a végnél eggyel nagyobb index használatával:
A szeletek dinamikusak, így a Rust futás közben tudja meghatározni a hosszukat. A szeleteket argumentumként is átadhatja a függvényeknek anélkül, hogy kupackiosztásra lenne szüksége.
Általában szeleteket használ a karakterlánc-műveletekhez és az adatok részhalmazainak átadásához a függvényeknek. Hatékony és hatékony eszköz a Rust gyűjtemények kezelésére, rugalmasabb alternatívát biztosítva a tömbökhöz.
WebAssembly-alapú előtérbeli webalkalmazásokat készíthet a Rustban
Az adattípusok ismerete kulcsfontosságú a Rust utazás során, mivel ezeket a legtöbb művelethez használni fogja az alkalmazások építése során.
A WebAssembly egy alacsony szintű bináris formátum, amely modern webböngészőkön fut, szinte natív teljesítménnyel. Lehetővé teszi kód írását számos különböző nyelven, és átültetheti a WebAssembly-be.
A WebAssembly a Rust révén egyre népszerűbb. Számos keretrendszer létezik, például a Yew, a Sycamore és a Seed, amelyek segítségével WebAssembly-alapú frontendeket építhet a Rust segítségével.
