Rust is een statisch getypte moderne programmeertaal die is ontworpen voor prestaties, betrouwbaarheid en veiligheid. Net als in andere statisch getypeerde talen, declareert u Rust-gegevenstypen tijdens het compileren. Dit maakt het gemakkelijker om typefouten op te sporen voordat u uw code uitvoert.
Rust biedt scalaire, samengestelde, referentietypen, structs, opsommingen en strings. De type-inferentie biedt functionaliteit voor het schrijven van beknopte code met behoud van de veiligheid van een statisch getypte taal.
Gehele getallen in roest
Rust biedt ondertekende en niet-ondertekende typen gehele getallen die zijn geclassificeerd op basis van het aantal bits. De typen gehele getallen met teken zijn i8, i16, i32, En i64 die respectievelijk 8-bits, 16-bits, 32-bits en 64-bits gehele getallen met teken vertegenwoordigen. Het ondersteunt ook niet-ondertekende integer-typen
u8, u16, u32, En u64, wat staat voor 8-bits, 16-bits, 32-bits en 64-bits niet-ondertekende gehele getallen.// gehele getallen met teken
laten een: i8 = -10;
laten b: i16 = -2048;
laten c: i32 = -2147483648;
laten d: i64 = -9223372036854775808;
// niet-ondertekende gehele getallen
laten e: u8 = 255;
laten v: u16 = 65535;
laten g: u32 = 4294967295;
laten u: u64 = 18446744073709551615;
Roest gebruikt de i32 typ standaard voor gehele getallen.
Roest drijvende-kommatypen
Roest zorgt f32 En f64 als drijvende-kommatypen die drijvende-kommagetallen met enkele precisie en dubbele precisie vertegenwoordigen. De f32 type gebruikt 32 bits om waarden op te slaan, en de f64 type gebruikt 64 bits.
Drijvende-kommagetallen in Rust volgen de IEEE 754-standaard voor drijvende-kommaberekeningen.
laten een = 3.14159265358979323_f32;
laten b = 2.718281828459045235_f64;
Rust-booleans gebruiken
Roest zorgt voor een boel typ om te vertegenwoordigen WAAR of vals waarden. Booleans worden vaak gebruikt in conditionele en controlestroomverklaringen voor programmabesluitvorming.
laten variabele_1: bool = WAAR;
laten variabele_2: bool = vals;
U kunt booleaanse waarden vergelijken met de gelijkheidsoperator, ==, en de ongelijkheidsoperator, !=. Rust definieert de vergelijkingsoperatoren niet, , <=, En >=, voor boel waarden.
laten variabele_1: bool = WAAR;
laten variabele_2: bool = vals;
als variabele_1 == variabele_2 {
println!("variabele_1 is gelijk aan variabele_2");
} andersals variabele_1 != variabele_2 {
println!("variabele_1 is niet gelijk aan variabele_2");
}
Het Char-type
De Roest char type vertegenwoordigt een enkele Unicode scalaire waarde die elk teken in kan vertegenwoordigen de Unicode-standaard. U kunt een char waarde met behulp van enkele aanhalingstekens.
// Een char-waarde declareren
laten c = 'A';
De char type is handig voor het werken met emoji's in Rust.
Tupels in Roest
Met de tuple-gegevensstructuur kunt u meer dan één waarde groeperen in één samengestelde waarde. Deze waarden kunnen hetzelfde type of verschillende typen hebben. U kunt tuples declareren door ze te schrijven als een door komma's gescheiden lijst met waarden tussen haakjes.
Hier leest u hoe u een tuple kunt declareren met 32-bits gehele getallen, tekenreeksen en float64-waarden.
laten tup: (i32, &str, f64) = (500, "Hallo", 3.14);
Tuples hebben een vaste lengte en u kunt ze gebruiken om meerdere waarden van een functie te retourneren of om meerdere waarden als één argument aan functies door te geven.
U kunt toegang krijgen tot individuele elementen van een tuple door deze te destructureren met behulp van patroonvergelijking of door rechtstreeks toegang te krijgen tot individuele elementen met behulp van punt (.) syntaxis en een index.
Hier ziet u hoe u toegang kunt krijgen tot individuele elementen van een structuur met behulp van patroonvergelijking:
laten mijn_tuple = (10, "Hallo Wereld!", vals);laten (x, y, z) = mijn_tuple;
println!("Het eerste element is: {}", X);
println!("Het tweede element is: {}", y);
println!("Het derde element is: {}", z);
Zo krijgt u toegang tot individuele elementen met puntnotatie:
laten mijn_tuple = (10, "Hallo Wereld!", vals);
println!("DeEerstelementis: {}", mijn_tuple.0);
println!("Desecondeelementis: {}", mijn_tuple.1);
println!("Dederdeelementis: {}", mijn_tuple.2);
Tuples zijn erg handig bij het groeperen van gerelateerde gegevens in één enkele waarde. Ze kunnen ook de leesbaarheid van uw code verbeteren als u ze spaarzaam gebruikt.
Arrays in roest
Een array is een verzameling elementen van hetzelfde type met een vaste lengte. U schrijft Rust-arrays als een lijst met waarden tussen vierkante haakjes, gescheiden door komma's.
Hier leest u hoe u arrays in Rust kunt declareren:
laten arr = [1, 2, 3, 4, 5];
U kunt het aantal elementen in een array niet meer wijzigen nadat u deze hebt gedeclareerd, maar u kunt afzonderlijke elementen van een array openen, wijzigen en manipuleren met behulp van indexering.
laten mut mijn_array = [1, 2, 3, 4, 5];// Toegang tot elementen
println!("DeEerstelementis: {}", mijn_array[0]);// Elementen wijzigen
mijn_array[0] = 100;
println!("DeEerstelementnawijzigingis: {}", mijn_array[0]);// Een array doorlopen en elementen manipuleren
vooriin 0..mijn_array.len() {
mijn_array[i] *= 2;
}
// afdrukken van de array
println!("De array na manipulatie: {:?}", mijn_array);
Roest Arrays zijn opgeslagen op de stapel en hebben een aaneengesloten geheugentoewijzing, zodat toegang tot elementen van een array snel en efficiënt is. Dit maakt arrays geschikt voor situaties waarin u veel elementen moet opslaan en verwerken.
Werken Met Roestplakjes
Een slice is een gegevensstructuur waarmee naar een aaneengesloten reeks elementen in een verzameling kan worden verwezen. Plakjes worden vertegenwoordigd door de &[T] type, waarbij T het type elementen is dat in de slice is opgeslagen.
fn voornaamst(){
// declareer een array
laten mijn_array = [1, 2, 3, 4, 5];// maak een segment van de array
laten mijn_segment = &mijn_array[1..3];
// druk het segment af
println!("Plak: {:?}", mijn_slice);
}
Merk op hoe de bereiksyntaxis, .., haalt een segment uit een array met behulp van de beginindex en een index die één groter is dan het einde:
Slices zijn dynamisch, dus Rust kan hun lengte tijdens runtime bepalen. U kunt segmenten ook doorgeven als argumenten aan functies zonder dat er heaptoewijzing nodig is.
U zult gewoonlijk segmenten gebruiken voor tekenreeksbewerkingen en om subsets van gegevens door te geven aan functies. Ze zijn een krachtige en efficiënte tool voor het beheren van collecties in Rust en bieden een flexibeler alternatief voor arrays.
U kunt door WebAssembly aangedreven frontend-webapps bouwen in Rust
Kennis van gegevenstypen is cruciaal voor uw Rust-reis, aangezien u ze voor de meeste bewerkingen zult gebruiken tijdens het bouwen van applicaties.
WebAssembly is een low-level binair formaat dat draait op moderne webbrowsers, met bijna native prestaties. Hiermee kunt u code in veel verschillende talen schrijven en deze naar WebAssembly transpileren.
WebAssembly wint aan acceptatie door Rust. Er zijn veel frameworks zoals Yew, Sycamore en Seed die u kunt gebruiken om WebAssembly-aangedreven frontends met Rust te bouwen.