Rostschutzstrukturen und wie man sie verwendet

Kontrollstrukturen sind ein Programmierkonstrukt, mit dem Sie den Ausführungsfluss in Ihren Programmen steuern können. Mit Kontrollstrukturen können Sie Anweisungen angeben, die nur ausgeführt werden, wenn bestimmte Bedingungen erfüllt sind.

Die Kontrollstrukturen von Rust sind entscheidend für die Verwaltung des Programmflusses, ermöglichen eine effiziente Codeausführung und vereinfachen gleichzeitig komplexe Aufgaben in kleinere, wiederverwendbare Komponenten.

Rust-bedingte Anweisungen

Bedingte Anweisungen sind Konstrukte, mit denen Sie Code basierend auf Bedingungen ausführen können. Bedingte Anweisungen sind praktisch für die Entscheidungsfindung, da die Ausführung des Programms davon abhängt, ob die Bedingung zu ausgewertet wird WAHR oder FALSCH. Rost bietet Wenn, anders, Und passen Aussagen zur Entscheidungsfindung.

In Rust-Programmen wird die Wenn -Anweisung testet, ob eine bestimmte Bedingung wahr ist. Wenn dies der Fall ist, führt das Programm den zugehörigen Codeblock aus. Wenn die Bedingung als falsch ausgewertet wird, überspringt das Programm diesen Codeblock und fährt mit der nächsten Anweisung fort oder führt die aus

anders Anweisungsblock, falls vorhanden.

Der passen -Anweisung ist ein leistungsstarkes Kontrollflusskonstrukt, das es einem Programm ermöglicht, Werte mit einer Reihe von Mustern abzugleichen und Code basierend auf dem übereinstimmenden Muster auszuführen.

Rusts if-Anweisungen

Sie werden erklären Wenn -Anweisungen in Ihren Rust-Programmen mit der Wenn Schlüsselwort gefolgt von einer Bedingung:

Wenn Zustand {
// auszuführender Code, wenn die Bedingung wahr ist
}

Hier ist ein Beispiel dafür, wie Sie eine if-Anweisung in Ihren Rust-Programmen verwenden können:

fnhauptsächlich() {
lassen x= 15;
Wenn x > 10 {
drucken!("x ist größer als 10");
 }
}

Der X Die Variable enthält eine 32-Bit-Ganzzahl, und die if-Anweisung prüft, ob der Wert von x größer als zehn ist, bevor der Codeblock ausgeführt wird, der ihn ausgibt.

Rusts andere Aussagen

Sie verwenden die anders Schlüsselwort, um einen Codeblock auszuführen, wenn Sie davon ausgehen, dass ein Wenn Aussage als falsch gewertet würde.

Wenn Zustand {
// auszuführender Code, wenn die Bedingung wahr ist
} anders {
// auszuführender Code, wenn die Bedingung falsch ist
}

Hier ist ein Beispiel, wo X nicht größer als 10 ist, die Wenn Aussage bewertet FALSCH, und ein anders Aussage läuft.

fnhauptsächlich(){
lassen x= 5;
Wenn x > 10 {
drucken!("x ist größer als 10");
 } anders {
drucken!("x ist nicht größer als 10");
 }
}

Seit X 5 ist und 5 nicht größer als 10 ist, überspringt das Programm die Wenn Block und führt die aus anders Block.

Rusts Match-Statements

Sie verwenden die passen Schlüsselwort für komplexe Entscheidungsfindung, um eine Reihe von Mustern zu überprüfen und Code basierend auf Musterübereinstimmungen auszuführen. Spielaussagen sind ähnlich wie switch-Anweisungen in C#, Go und C++.

Hier ist die Struktur einer Rust-Match-Anweisung:

passen Wert {
 Muster1 => {
// auszuführender Code, wenn der Wert mit Muster1 übereinstimmt
 },
 Muster2 => {
// auszuführender Code, wenn der Wert mit Muster2 übereinstimmt
 },
// usw.
}

So können Sie Match-Anweisungen in Ihren Programmen verwenden:

lassen Klasse = 'B';
passen Grad {
'A' => drucken!("Ausgezeichnete Arbeit!"),
'B' => drucken!("Gut gemacht."),
'C' => drucken!("Du könntest das besser machen."),
 _ => drucken!("Das ist keine gültige Note."),
}

Der Grad Variable ist ein Zeichen, und die passen -Anweisung prüft, welches der Zeichen den Wert der grade-Variablen ergibt, bevor der Code nach dem =>-Operator ausgeführt wird. Sie können das Unterstrichmuster (_) verwenden, um Werte abzugleichen, die nicht mit anderen Mustern (dem Standardmuster) übereinstimmen.

Schleifen in Rost

Schleifen sind ein grundlegendes Konstrukt, das für sich wiederholende Aufgaben wie z Web-Scraping und andere automatisierte Aktionen. Rust bietet verschiedene Arten von Schleifen, einschließlich während Schleifen, für Schleifen und die Schleife Schleife.

Rusts While-Schleifen

While-Schleifen wiederholen einen Codeblock, solange eine angegebene Bedingung wahr ist. Bevor Sie die Bedingung angeben, geben Sie While-Schleifen in Rust mit dem an während Stichwort.

während Zustand {
// auszuführender Code
}

Die Bedingung sollte ein boolescher Ausdruck sein, der die Fortsetzung der Schleife bestimmt. Wenn die Bedingung als falsch ausgewertet wird, wird die Schleife beendet.

Hier ist ein Beispiel für eine Rust-While-Schleife, die Zahlen von eins bis fünf ausgibt.

fnhauptsächlich() {
lassenmut ich = 1;
während ich <= 5 {
drucken!("{}", ich);
 ich += 1;
 }
}

Die While-Schleife in der hauptsächlich Die Funktion durchläuft die Zahlen eins bis fünf und erhöht dabei die ich variabel um eins bis ich Variable größer als fünf ist, wo die Schleife endet.

Die Schleife Schleife

Der Schleife Das Schlüsselwort erstellt eine Endlosschleife, bis Sie mit dem einen Ausgang angeben brechen Stichwort.

Schleife {
// auszuführender Code
Wenn Zustand {
brechen;
 }
}

Der Code in der Schleife Block wird weiter ausgeführt, bis die Schleife auf a trifft brechen Stichwort.

Hier ist ein Beispiel für die Verwendung von Schleife Schleife, um die Zahlen eins bis fünf auszugeben, bevor die angegeben wird brechen Schlüsselwort für den Ausgang.

fnhauptsächlich() {
lassenmut ich = 1;
Schleife {
drucken!("{}", ich);
 ich += 1;
Wenn ich > 5 {
brechen;
 }
 }
}

Der hauptsächlich Funktion führt die Schleife aus, und die Wenn Anweisung erhöht die ich Variable. Der Wenn -Anweisung gibt die Beendigung der Schleife an, wenn die ich Variable überschreitet fünf.

Rust ist für Loops

In Rust iterieren for-Schleifen durch einen Bereich oder eine Sammlung von Werten. Sie verwenden die für Schlüsselwort, um eine for-Schleife zu starten, bevor der Bereich oder die Sammlung angegeben wird, auf die sie wirkt.

für Variable In Bereich {
// auszuführender Code
}

Der Bereich ist ein Ausdruck, der zu einer Folge von Werten ausgewertet wird, und die Variable ist eine Variable, die der Reihe nach jeden Wert in der Folge annimmt. Der Codeblock wird einmal für jeden Wert in der Sequenz ausgeführt.

Hier ist ein Beispiel für eine for-Schleife, die Werte von eins bis zehn ausgibt.

fnhauptsächlich() {
für ich In1..=10 {
drucken!("{}", ich);
 }
}

Die Schleife durchläuft die Werte von 1 bis 10. Bei jeder Iteration enthält die Variable (i) den nächsten Wert, den die drucken! Makro wird dann ausgedruckt.

Du kannst den... benutzen weitermachen Schlüsselwort zum Überspringen von Werten in for-Schleifen. So können Sie die geraden Zahlen überspringen, wenn Sie in einem Bereich arbeiten:

fnhauptsächlich() {
für Anzahl In1..=10 {
Wenn Anzahl % 2 == 0 {
weitermachen; // gerade Zahlen überspringen
 }
drucken!("{}", num); // ungerade Zahlen drucken
 }
}

Der Wenn Anweisung verwendet die weitermachen Schlüsselwort, um anzugeben, dass die Schleife Zahlen überspringen soll, die durch zwei teilbar sind.

Außerdem können Sie eine for-Schleife mit verlassen brechen Stichwort. Die Schleife endet beim Auftreffen auf die brechen Stichwort.

fnhauptsächlich() {
für Anzahl In1..=10 {
Wenn Zahl == 5 {
brechen; // Schleife verlassen, wenn Zahl gleich 5 ist
 }
drucken!("{}", num); // Zahlen 1 bis 4 drucken
 }
}

Der Wenn -Anweisung gibt an, dass die Schleife beendet werden soll, wenn die ich Variable gleich fünf.

Verwenden Sie Rusts Kontrollstrukturen mit Datentypen, um die Sprache zu beherrschen

Rust bietet diese flexiblen Kontrollstrukturen für Operationen auf eingebauten und benutzerdefinierten Datentypen. Sie können diese Kontrollstrukturen verwenden, um mit zusammengesetzten und zusammengesetzten Datenstrukturen wie Arrays, Vektoren, Strukturen und Aufzählungen zu arbeiten.

Rust stellt auch Strukturen bereit. Strukturen sind Datenstrukturen, die zusammengehörige Werte in einem einzigen Objekt gruppieren. Sie ähneln Klassen in objektorientierten Sprachen, und Sie können sogar Methoden für sie definieren.