Rust ist eine statisch typisierte moderne Programmiersprache, die auf Leistung, Zuverlässigkeit und Sicherheit ausgelegt ist. Wie in anderen statisch typisierten Sprachen deklarieren Sie Rust-Datentypen zur Kompilierzeit. Dies erleichtert das Abfangen von Typfehlern, bevor Sie Ihren Code ausführen.
Rust bietet skalare, zusammengesetzte, Referenztypen, Strukturen, Aufzählungen und Zeichenfolgen. Sein Typrückschluss bietet Funktionen zum Schreiben von prägnantem Code, während die Sicherheit einer statisch typisierten Sprache gewahrt bleibt.
Ganzzahlen in Rust
Rust bietet vorzeichenbehaftete und vorzeichenlose Integer-Typen, die nach der Anzahl der Bits klassifiziert sind. Die vorzeichenbehafteten Integer-Typen sind i8, i16, i32, Und i64 die 8-Bit-, 16-Bit-, 32-Bit- bzw. 64-Bit-Ganzzahlen mit Vorzeichen darstellen. Es werden auch vorzeichenlose Integer-Typen unterstützt
u8, u16, u32, Und u64, die 8-Bit-, 16-Bit-, 32-Bit- und 64-Bit-Ganzzahlen ohne Vorzeichen darstellt.// vorzeichenbehaftete Ganzzahlen
lassen a: i8 = -10;
lassen b: i16 = -2048;
lassen c: i32 = -2147483648;
lassen d: i64 = -9223372036854775808;
// Ganzzahlen ohne Vorzeichen
lassen e: u8 = 255;
lassen f: u16 = 65535;
lassen g: u32 = 4294967295;
lassen h: u64 = 18446744073709551615;
Rust verwendet die i32 Typ für Integer-Literale standardmäßig.
Rust-Gleitkommatypen
Rost bietet f32 Und f64 als Gleitkommatypen, die Gleitkommazahlen mit einfacher und doppelter Genauigkeit darstellen. Der f32 Typ verwendet 32 Bits zum Speichern von Werten, und die f64 Typ verwendet 64 Bit.
Gleitkommazahlen in Rust folgen dem IEEE 754-Standard für Gleitkommaarithmetik.
lassen ein = 3.14159265358979323_f32;
lassen b = 2.718281828459045235_f64;
Verwenden von Rust-Booleans
Rost bietet a bool Art darzustellen WAHR oder FALSCH Werte. Boolesche Werte werden häufig in bedingten Anweisungen und Ablaufsteuerungsanweisungen für die Programmentscheidung verwendet.
lassen variable_1: bool = WAHR;
lassen variable_2: bool = FALSCH;
Sie können boolesche Werte mit dem Gleichheitsoperator vergleichen, ==, und der Ungleichheitsoperator, !=. Rust definiert die Vergleichsoperatoren nicht, , <=, Und >=, für bool Werte.
lassen variable_1: bool = WAHR;
lassen variable_2: bool = FALSCH;
wenn Variable_1 == Variable_2 {
println!("Variable_1 ist gleich Variable_2");
} andersWenn Variable_1 != Variable_2 {
println!("Variable_1 ist nicht gleich Variable_2");
}
Der Char-Typ
Der Rost verkohlen type stellt einen einzelnen Unicode-Skalarwert dar, der jedes beliebige Zeichen in darstellen kann der Unicode-Standard. Sie können eine angeben verkohlen Wert mit einfachen Anführungszeichen.
// Zeichenwert deklarieren
lassen c = 'A';
Der verkohlen type ist hilfreich für die Arbeit mit Emojis in Rust.
Tupel in Rost
Mit der Tupel-Datenstruktur können Sie mehr als einen Wert zu einem einzigen zusammengesetzten Wert gruppieren. Diese Werte können den gleichen Typ oder unterschiedliche Typen haben. Sie können Tupel deklarieren, indem Sie sie als kommagetrennte Liste von Werten schreiben, die von Klammern umgeben sind.
So können Sie ein Tupel mit 32-Bit-Ganzzahlen, Zeichenfolgen und Float64-Werten deklarieren.
lassen tup: (i32, &str, f64) = (500, "Hallo", 3.14);
Tupel haben eine feste Länge, und Sie können sie verwenden, um mehrere Werte von einer Funktion zurückzugeben oder mehrere Werte als einzelnes Argument an Funktionen zu übergeben.
Sie können auf einzelne Elemente eines Tupels zugreifen, indem Sie es mithilfe von Mustervergleichen destrukturieren oder direkt auf einzelne Elemente zugreifen, indem Sie die Punktsyntax (.) und einen Index verwenden.
So können Sie mithilfe des Musterabgleichs auf einzelne Elemente einer Struktur zugreifen:
lassen my_tuple = (10, "Hallo Welt!", FALSCH);lassen (x, y, z) = my_tuple;
println!("Das erste Element ist: {}", X);
println!("Das zweite Element ist: {}", ja);
println!("Das dritte Element ist: {}", z);
So können Sie mit Punktnotation auf einzelne Elemente zugreifen:
lassen my_tuple = (10, "Hallo Welt!", FALSCH);
println!("DerErsteElementIst: {}", mein_tupel.0);
println!("DerzweiteElementIst: {}", mein_tupel.1);
println!("DerdritteElementIst: {}", mein_tupel.2);
Tupel sind sehr nützlich, wenn Sie zusammengehörige Daten zu einem einzigen Wert gruppieren. Sie können auch die Lesbarkeit Ihres Codes verbessern, wenn Sie sie sparsam verwenden.
Arrays in Rost
Ein Array ist eine Sammlung von Elementen des gleichen Typs mit fester Länge. Sie schreiben Rust-Arrays als eine Liste von Werten in eckigen Klammern, die durch Kommas getrennt sind.
So können Sie Arrays in Rust deklarieren:
lassen arr = [1, 2, 3, 4, 5];
Sie können die Anzahl der Elemente in einem Array nach der Deklaration nicht mehr ändern, aber Sie können mithilfe der Indizierung auf einzelne Elemente eines Arrays zugreifen, diese ändern und manipulieren.
lassen mut my_array = [1, 2, 3, 4, 5];// Auf Elemente zugreifen
println!("DerErsteElementIst: {}", mein_array[0]);// Elemente ändern
mein_array[0] = 100;
println!("DerErsteElementnachÄnderungIst: {}", mein_array[0]);// Ein Array durchlaufen und Elemente manipulieren
fürichIn 0..my_array.len() {
mein_array[i] *= 2;
}
// Drucken des Arrays
println!("Das Array nach der Manipulation: {:?}", mein_array);
Rust Arrays sind auf dem Stapel gespeichert und verfügen über eine zusammenhängende Speicherzuweisung, sodass der Zugriff auf Elemente eines Arrays schnell und effizient ist. Dadurch eignen sich Arrays für Situationen, in denen Sie viele Elemente speichern und verarbeiten müssen.
Arbeiten mit Rostscheiben
Ein Slice ist eine Datenstruktur, die es ermöglicht, auf eine zusammenhängende Folge von Elementen in einer Sammlung zu verweisen. Slices werden durch die dargestellt &[T] Typ, wobei T der Typ der im Slice gespeicherten Elemente ist.
fn hauptsächlich(){
// ein Array deklarieren
lassen mein_array = [1, 2, 3, 4, 5];// einen Slice aus dem Array erstellen
lassen my_slice = &my_array[1..3];
// Slice drucken
println!("Scheibe: {:?}", my_slice);
}
Beachten Sie, wie die Bereichssyntax, .., extrahiert einen Slice aus einem Array mit dem Startindex und einem Index, der um eins größer als das Ende ist:
Slices sind dynamisch, sodass Rust ihre Länge zur Laufzeit bestimmen kann. Sie können Slices auch als Argumente an Funktionen übergeben, ohne dass eine Heap-Zuweisung erforderlich ist.
Sie verwenden Slices häufig für Zeichenfolgenoperationen und um Teilmengen von Daten an Funktionen zu übergeben. Sie sind ein leistungsstarkes und effizientes Werkzeug zum Verwalten von Sammlungen in Rust und bieten eine flexiblere Alternative zu Arrays.
Sie können WebAssembly-betriebene Frontend-Web-Apps in Rust erstellen
Die Kenntnis von Datentypen ist für Ihre Rust-Reise von entscheidender Bedeutung, da Sie sie für die meisten Vorgänge beim Erstellen von Anwendungen verwenden werden.
WebAssembly ist ein Low-Level-Binärformat, das auf modernen Webbrowsern mit nahezu nativer Leistung ausgeführt wird. Damit können Sie Code in vielen verschiedenen Sprachen schreiben und in WebAssembly transpilieren.
WebAssembly gewinnt durch Rust an Akzeptanz. Es gibt viele Frameworks wie Yew, Sycamore und Seed, die Sie verwenden können, um WebAssembly-basierte Frontends mit Rust zu erstellen.
