Rust este un limbaj de programare modern tip static, conceput pentru performanță, fiabilitate și securitate. Ca și în alte limbi tipizate static, declari tipurile de date Rust în timpul compilării. Acest lucru facilitează identificarea erorilor de tip înainte de a rula codul.
Rust oferă tipuri scalare, compuse, de referință, structuri, enumerări și șiruri. Inferența de tip oferă funcționalitate pentru scrierea unui cod concis, menținând în același timp siguranța unui limbaj tipizat static.
Numerele întregi în Rust
Rust oferă tipuri de numere întregi semnate și nesemnate, clasificate în funcție de numărul de biți. Tipurile întregi cu semn sunt i8, i16, i32, și i64 reprezentând numere întregi cu semn de 8 biți, 16 biți, 32 de biți și, respectiv, 64 de biți. De asemenea, acceptă tipurile întregi nesemnate u8, u16, u32, și u64, reprezentând numere întregi fără semn de 8 biți, 16 biți, 32 de biți și 64 de biți.
// numere întregi cu semn
lăsa a: i8 = -10;
lăsa b: i16 = -2048;
lăsa c: i32 = -2147483648;
lăsa d: i64 = -9223372036854775808;
// numere întregi fără semn
lăsa e: u8 = 255;
lăsa f: u16 = 65535;
lăsa g: u32 = 4294967295;
lăsa h: u64 = 18446744073709551615;
Rust folosește i32 tastați implicit pentru literali întregi.
Tipuri cu virgulă mobilă de rugină
Rugina oferă f32 și f64 ca tipuri în virgulă mobilă care reprezintă numere în virgulă mobilă cu precizie simplă și dublă precizie. The f32 tipul folosește 32 de biți pentru a stoca valori și f64 tipul folosește 64 de biți.
Numerele în virgulă mobilă în Rust urmează standardul IEEE 754 pentru aritmetica în virgulă mobilă.
lăsa a = 3.14159265358979323_f32;
lăsa b = 2.718281828459045235_f64;
Folosind booleenii Rust
Rugina oferă o bool tip pentru a reprezenta Adevărat sau fals valorile. Booleenii sunt adesea folosiți în instrucțiunile de flux condițional și de control pentru luarea deciziilor de program.
lăsa variabila_1: bool = Adevărat;
lăsa variabila_2: bool = fals;
Puteți compara valorile booleene cu operatorul de egalitate, ==, și operatorul inegalității, !=. Rust nu definește operatorii de comparație, , <=, și >=, pentru bool valorile.
lăsa variabila_1: bool = Adevărat;
lăsa variabila_2: bool = fals;
daca variabila_1 == variabila_2 {
println!(„variabila_1 este egală cu variabila_2”);
} altfeldacă variabila_1 != variabila_2 {
println!(„variabila_1 nu este egală cu variabila_2”);
}
Tipul Char
Rugina char tipul reprezintă o singură valoare scalară Unicode care poate reprezenta orice caracter în standardul Unicode. Puteți specifica a char valoare folosind ghilimele simple.
// Declararea unei valori char
lăsa c = 'A';
The char tipul este util pentru lucrul cu emoji-uri în Rust.
Tupluri în rugină
Structura de date tuple vă permite să grupați mai multe valori într-o singură valoare compusă. Aceste valori pot avea același tip sau tipuri diferite. Puteți declara tupluri scriindu-le ca o listă de valori separate prin virgulă, înconjurată de paranteze.
Iată cum puteți declara un tuplu cu numere întregi de 32 de biți, șiruri și valori float64.
lăsa tup: (i32, &str, f64) = (500, "Buna ziua", 3.14);
Tuplurile au o lungime fixă și le puteți folosi pentru a returna mai multe valori dintr-o funcție sau pentru a transmite mai multe valori la funcții ca un singur argument.
Puteți accesa elemente individuale ale unui tuplu prin destructurarea acestuia folosind potrivirea modelului sau accesând direct elemente individuale folosind sintaxa punct (.) și un index.
Iată cum puteți accesa elementele individuale ale unei structuri folosind potrivirea modelelor:
lăsa my_tuple = (10, "Salut Lume!", fals);lăsa (x, y, z) = my_tuple;
println!(„Primul element este: {}”, X);
println!(„Al doilea element este: {}”, y);
println!(„Al treilea element este: {}”, z);
Iată cum puteți accesa elemente individuale folosind notația cu puncte:
lăsa my_tuple = (10, "Salut Lume!", fals);
println!("Theprimulelementeste: {}", my_tuple.0);
println!("Theal doileaelementeste: {}", my_tuple.1);
println!("Theal treileaelementeste: {}", my_tuple.2);
Tuplurile sunt foarte utile atunci când se grupează datele asociate într-o singură valoare. Ele pot îmbunătăți, de asemenea, lizibilitatea codului dvs. dacă le utilizați cu moderație.
Arrays in Rust
Un tablou este o colecție de elemente de același tip cu o lungime fixă. Scrieți tablourile Rust ca o listă de valori între paranteze pătrate, separate prin virgule.
Iată cum puteți declara matrice în Rust:
lăsa arr = [1, 2, 3, 4, 5];
Nu puteți modifica numărul de elemente dintr-o matrice odată ce l-ați declarat, dar puteți accesa, modifica și manipula elemente individuale ale unei matrice folosind indexarea.
lăsa mut my_array = [1, 2, 3, 4, 5];// Accesarea elementelor
println!("Theprimulelementeste: {}", matricea_mea[0]);// Modificarea elementelor
my_array[0] = 100;
println!("Theprimulelementdupămodificareeste: {}", matricea_mea[0]);// Buclă peste o matrice și manipularea elementelor
pentruiîn 0..matricea_mea.len() {
matricea_mea[i] *= 2;
}
// imprimarea matricei
println!(„Matricea după manipulare: {:?}”, my_array);
Rust Arrays sunt depozitate pe stivă și au o alocare de memorie contiguă, astfel încât accesarea elementelor unei matrice este rapidă și eficientă. Acest lucru face ca matricele să fie potrivite pentru situațiile în care trebuie să stocați și să procesați multe elemente.
Lucrul cu felii de rugină
O slice este o structură de date care permite referirea unei secvențe adiacente de elemente dintr-o colecție. Feliile sunt reprezentate de &[T] tip, unde T este tipul de elemente stocate în felie.
fn principal(){
// declara o matrice
lăsa matricea_mea = [1, 2, 3, 4, 5];// creează o porțiune din matrice
lăsa felia_mea = &matricea_mea[1..3];
// tipăriți felia
println!(„Felie: {:?}”, felia_mea);
}
Observați cum sintaxa intervalului, .., extrage o porțiune dintr-o matrice folosind indexul de început și un index mai mare decât sfârșitul:
Feliile sunt dinamice, astfel încât Rust le poate determina lungimea în timpul rulării. De asemenea, puteți trece felii ca argumente pentru funcții fără a fi nevoie de alocare heap.
Veți folosi de obicei felii pentru operații cu șir și pentru a transmite subseturi de date la funcții. Sunt un instrument puternic și eficient pentru gestionarea colecțiilor în Rust, oferind o alternativă mai flexibilă la matrice.
Puteți construi aplicații web front-end bazate pe WebAssembly în Rust
Cunoașterea tipurilor de date este esențială pentru călătoria dvs. Rust, deoarece le veți folosi pentru majoritatea operațiunilor în timp ce creați aplicații.
WebAssembly este un format binar de nivel scăzut care rulează pe browsere web moderne, cu performanțe aproape native. Vă permite să scrieți cod în multe limbi diferite și să-l transpilați în WebAssembly.
WebAssembly câștigă adoptare prin Rust. Există multe cadre precum Yew, Sycamore și Seed pe care le puteți folosi pentru a construi front-end-uri bazate pe WebAssembly cu Rust.
