Kontrollstrukturen (if, else, loop, while, for)(Rust Programmiersprache)
Kontrollstrukturen (if, else, loop, while, for) in der Programmiersprache Rust
Kontrollstrukturen sind ein wesentlicher Bestandteil jeder Programmiersprache. In Rust gibt es mehrere Kontrollstrukturen, die es ermöglichen, den Ablauf eines Programms zu steuern.
if und else
Die `if`- und `else`-Anweisungen werden verwendet, um bedingte Ausführungen zu ermöglichen.
fn main() { let number = 5; if number < 10 { println!("Die Zahl ist kleiner als 10"); } else { println!("Die Zahl ist 10 oder größer"); } }
Match
Die `match`-Anweisung wird verwendet, um verschiedene Fälle zu überprüfen und entsprechende Aktionen auszuführen.
Verwendung der match-Anweisung
Die `match`-Anweisung wird verwendet, um ein Muster abzugleichen und basierend auf dem Ergebnis verschiedene Aktionen auszuführen.
fn main() { let number = 3; match number { 1 => println!("Eins"), 2 => println!("Zwei"), 3 => println!("Drei"), _ => println!("Andere Zahl"), } }
Verwendung von match mit Enums
Die `match`-Anweisung kann auch mit Enums verwendet werden, um verschiedene Varianten zu behandeln.
enum Color { Red, Green, Blue, } fn main() { let color = Color::Red; match color { Color::Red => println!("Rot"), Color::Green => println!("Grün"), Color::Blue => println!("Blau"), } }
Verwendung von match mit Tupeln
Die `match`-Anweisung kann verwendet werden, um Tupel zu entpacken und verschiedene Kombinationen zu behandeln.
fn main() { let pair = (2, 3); match pair { (0, y) => println!("Erstes Element ist 0 und zweites Element ist {}", y), (x, 0) => println!("Erstes Element ist {} und zweites Element ist 0", x), _ => println!("Kein Element ist 0"), } }
Verwendung von match mit Referenzen
Die `match`-Anweisung kann verwendet werden, um Referenzen zu entpacken und verschiedene Muster zu behandeln.
fn main() { let x = &5; match x { &val => println!("Der Wert ist {}", val), } match *x { val => println!("Der Wert ist {}", val), } }
Diese Beispiele zeigen, wie die `match`-Anweisung in Rust verwendet werden kann, um verschiedene Muster zu behandeln und den Programmablauf basierend auf diesen Mustern zu steuern.
loop
Die `loop`-Anweisung wird verwendet, um eine Endlosschleife zu erstellen. Sie kann mit `break` beendet werden.
fn main() { let mut counter = 0; loop { counter += 1; if counter == 10 { break; } } println!("Die Schleife wurde {} Mal durchlaufen", counter); }
while
Die `while`-Anweisung wird verwendet, um eine Schleife zu erstellen, die so lange läuft, wie eine Bedingung wahr ist.
Verwendung der while-Schleife
Die `while`-Schleife wird verwendet, um eine Schleife zu erstellen, die so lange läuft, wie eine Bedingung wahr ist.
fn main() { let mut number = 3; while number != 0 { println!("{}", number); number -= 1; } println!("Liftoff!"); }
Verwendung der while-Schleife mit einer Bedingung
Die `while`-Schleife kann verwendet werden, um eine Schleife zu erstellen, die nur unter bestimmten Bedingungen ausgeführt wird.
fn main() { let mut count = 0; while count < 5 { println!("Count ist {}", count); count += 1; } }
Verwendung der while-Schleife mit einem Iterator
Die `while`-Schleife kann auch verwendet werden, um über einen Iterator zu iterieren.
fn main() { let mut numbers = vec![1, 2, 3, 4, 5]; let mut iter = numbers.iter(); while let Some(number) = iter.next() { println!("Die Zahl ist {}", number); } }
Verwendung der while-Schleife mit einer Option
Die `while`-Schleife kann verwendet werden, um eine Schleife zu erstellen, die so lange läuft, wie eine Option `Some` ist.
fn main() { let mut optional = Some(0); while let Some(i) = optional { if i > 9 { println!("Greater than 9, quit!"); optional = None; } else { println!("`i` ist `{}`. Weiter geht's.", i); optional = Some(i + 1); } } }
Diese Beispiele zeigen, wie die `while`-Schleife in Rust verwendet werden kann, um verschiedene Arten von Schleifen zu erstellen und den Programmablauf basierend auf Bedingungen zu steuern.
for
Die `for`-Anweisung wird verwendet, um über eine Sammlung von Elementen zu iterieren.
fn main() { let a = [10, 20, 30, 40, 50]; for element in a.iter() { println!("Der Wert ist: {}", element); } }
Iteration über einen Bereich
Die `for`-Schleife kann auch verwendet werden, um über einen Bereich von Zahlen zu iterieren.
fn main() { for number in 1..5 { println!("Die Zahl ist: {}", number); } }
Iteration über Zeichen in einem String
Die `for`-Schleife kann verwendet werden, um über die Zeichen in einem String zu iterieren.
fn main() { let s = String::from("hello"); for c in s.chars() { println!("{}", c); } }
Iteration über Schlüssel-Wert-Paare in einer HashMap
Die `for`-Schleife kann verwendet werden, um über die Schlüssel-Wert-Paare in einer HashMap zu iterieren.
use std::collections::HashMap; fn main() { let mut map = HashMap::new(); map.insert("Schlüssel1", 10); map.insert("Schlüssel2", 20);