Dies sind gängige boolesche Werte, die entweder wahr oder falsch sein können.

Charakter

Dieser Typ zeichnet sich durch die Bitbreite aus. Die von Rust unterstützte maximale Länge beträgt 128 Bit.

Eine vorzeichenbehaftete Ganzzahl variabler Größe (Größe hängt von der Größe des zugrunde liegenden Zeigers ab).

Ganzzahl ohne Vorzeichen variabler Größe (Größe hängt von der Größe des zugrunde liegenden Zeigers ab).

f32-Bit-Gleitkommatyp

f64-Bit-Gleitkommatyp

Bei einem Array fester Größe stellt T den Elementtyp dar, N stellt die Anzahl der Elemente dar und ist zur Kompilierungszeit eine nicht negative Konstante.

Eine dynamisch dimensionierte Ansicht einer zusammenhängenden Sequenz, wobei T einen beliebigen Typ darstellt.

String-Slicing, hauptsächlich als Referenz verwendet, d. h. &str

Endliche Folgen T und U können unterschiedlicher Art sein.

Eine Funktion, die einen Parameter vom Typ i32 empfängt und einen Parameter vom Typ i32 zurückgibt. Funktionen haben auch einen Typ.

fn add(a: u64, b: u64) -> u64 { ein b } fn main() { sei a: u64 = 17; sei b = 3; let result = add(a, b); println!("Ergebnis {}", Ergebnis); }

fn main() { sei doubler = |x|. sei Wert = 5; let two = doubler(value); println!("{} doubled is {}", value, double); let big_closure = |b, c| {. sei z = b c; z * zweimal }; let some_number = big_closure(1, 2); println!("Ergebnis aus Abschluss: {}", some_number); }

fn main() { let question = „Wie geht es dir?“; let person: String = "Bob".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", namaste, Frage, Person); }

Im obigen Code ist der Typ „Person“ und „Namaste“ „String“ und der Typ der Frage ist „&str“. Es gibt viele Möglichkeiten, Daten vom Typ String zu erstellen. Daten vom Typ „String“ werden in der Regel als Zeiger auf eine vorhandene Zeichenfolge im Stapel und im Heap gespeichert. Sie können aber auch Zeichenfolgen im Datensegment des kompilierten Objektcodes sein.

fn main() { let rust_is_awesome = true; if rust_is_awesome { println!("In der Tat"); } anders { println!("Nun, Sie sollten Rust ausprobieren!"); } }

fn main() { let result = if 1 == 2 { "Warte was?" } anders { „Rost macht Sinn“ }; println!("Weißt du was? {}.", result); }

Wenn der zuzuweisende Wert vom if else-Ausdruck zurückgegeben wird, müssen wir ein Semikolon als Endmarkierung verwenden. Wenn es sich beispielsweise um einen Ausdruck handelt, ist let eine Anweisung, die am Ende ein Semikolon erwartet.

fn req_status() -> u32 { 200 } fn main() { let status = req_status(); Spielstatus { 200 => println!("Erfolg"), 404 => println!("Nicht gefunden"), andere => { println!("Anfrage fehlgeschlagen mit Code: {}", other); } } }

fn main() { sei mut x = 1024; Schleife { wenn x < 0 { brechen; } println!("{} noch weitere Läufe", x); x -= 1; } }

fn silly_sub(a: i32, b: i32) -> i32 { let mut result = 0; 'inkrementieren: Schleife { wenn Ergebnis == a { sei mut dec = b; 'dekrementieren: Schleife { ifdec==0{ break 'inkrement; } anders { Ergebnis -= 1; dez -= 1; } } } anders { Ergebnis = 1; } } Ergebnis } fn main() { sei a = 10; sei b = 4; let result = silly_sub(a, b); println!("{} minus {} ist {}", a, b, result); }

fn main() { print!("Normaler Bereich: "); für i in 0..10 { drucken!("{},", i); } println!(); print!("Inklusive Bereich: "); für i in 0..=10 { drucken!("(),", i); } }

In Rust gibt es drei Formen der Strukturdeklaration. Die einfachste davon ist die Unit-Struktur, die mit dem Schlüsselwort struct deklariert wird, gefolgt von ihrem Namen und endet mit einem Semikolon.

Die zweite Strukturform ist die Tupelstruktur, die über zugehörige Daten verfügt. Jedes dieser Felder wird nicht benannt, sondern anhand seiner Position in der Definition referenziert.

Tupelstrukturen sind ideal für die Modellierung von Daten mit weniger als 5 Attributen. Jede andere Wahl beeinträchtigt die Lesbarkeit und Argumentation des Codes. Erstellen Sie für Datentypen mit mehr als drei Feldern Strukturen in einer C-ähnlichen Sprache. Dies ist die dritte Form und die am häufigsten verwendete Form.

Aufzählungen sind eine gute Möglichkeit, dies zu tun, wenn Sie verschiedene Arten von Dingen modellieren müssen. Es wird mit dem Schlüsselwort enum erstellt, gefolgt vom Namen der Aufzählung und einem Paar geschweifter Klammern. Innerhalb der geschweiften Klammern können wir alle möglichen Typen, also Varianten, schreiben. Diese Varianten können mit oder ohne Daten definiert werden, und die enthaltenen Daten können ein beliebiger Ferntyp, eine beliebige Struktur, eine Tupelstruktur oder sogar ein Aufzählungstyp sein.

Wir können einer definierten Struktur mithilfe von zwei Mechanismen Verhalten hinzufügen: konstruktorähnliche Funktionen sowie Getter- und Setter-Methoden.

Aufzählungen werden häufig in Zustandsautomaten verwendet und können bei Verwendung mit Übereinstimmungsausdrücken den Zustandsübergangscode sehr prägnant gestalten. Sie können auch zur Modellierung benutzerdefinierter Fehlertypen verwendet werden.

Jedes Rust-Programm benötigt ein Root-Modul. Bei ausführbaren Dateien ist es normalerweise die Datei main.rs und bei Bibliotheken normalerweise die Datei lib.rs.

Module können innerhalb anderer Module deklariert oder in Dateien und Verzeichnissen organisiert werden.

Damit der Compiler unser Modul erkennt, müssen wir das Schlüsselwort mod-Deklaration verwenden. In unserem Root-Modul müssen wir das Schlüsselwort use vor dem Modulnamen verwenden, was bedeutet, dass das Element in den Gültigkeitsbereich gebracht wird.

In einem Modul definierte Elemente sind standardmäßig privat und müssen Aufrufern über das Schlüsselwort pub zugänglich gemacht werden.

Arrays haben eine feste Länge und können Elemente desselben Typs speichern. Sie werden durch [T, N] dargestellt, wobei T einen beliebigen Typ und N die Anzahl der Array-Elemente darstellt. Die Größe des Arrays kann nicht durch eine Variable dargestellt werden und muss ein Literalwert von usize sein.

Unterthema