Rostschleife

Es kann Fälle geben, in denen ein Codeblock wiederholt ausgeführt werden muss. Im Allgemeinen werden Programmieranweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden ist die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen angegeben.

Rust bietet verschiedene Arten von Schleifen, um die Schleifenanforderungen zu erfüllen -

while
loop
for

Definitive Schleife

Eine Schleife, deren Anzahl von Iterationen eindeutig / fest ist, wird als bestimmte Schleife bezeichnet. Dasfor Schleife ist eine Implementierung einer bestimmten Schleife.

Für Schleife

Die for-Schleife führt den Codeblock für eine bestimmte Anzahl von Malen aus. Es kann verwendet werden, um einen festen Satz von Werten zu durchlaufen, z. B. ein Array. Die Syntax der for-Schleife ist wie folgt

Syntax

for temp_variable in lower_bound..upper_bound {
   //statements
}

Ein Beispiel für eine for-Schleife ist unten dargestellt

fn main(){
   for x in 1..11{ // 11 is not inclusive
      if x==5 {
         continue;
      }
      println!("x is {}",x);
   }
}

NOTE: dass auf die Variable x nur innerhalb des for-Blocks zugegriffen werden kann.

Ausgabe

x is 1
x is 2
x is 3
x is 4
x is 6
x is 7
x is 8
x is 9
x is 10

Unbestimmte Schleife

Eine unbestimmte Schleife wird verwendet, wenn die Anzahl der Iterationen in einer Schleife unbestimmt oder unbekannt ist.

Unbestimmte Schleifen können implementiert werden mit -

Sr.Nr.	Name & Beschreibung
1	While Die while- Schleife führt die Anweisungen jedes Mal aus, wenn die angegebene Bedingung als wahr ausgewertet wird
2	Loop Die Schleife ist eine while (true) unbestimmte Schleife

Illustration - für eine Weile

fn main(){
   let mut x = 0;
   while x < 10{
      x+=1;
      println!("inside loop x value is {}",x);
   }
   println!("outside loop x value is {}",x);
}

Die Ausgabe ist wie unten gezeigt -

inside loop x value is 1
inside loop x value is 2
inside loop x value is 3
inside loop x value is 4
inside loop x value is 5
inside loop x value is 6
inside loop x value is 7
inside loop x value is 8
inside loop x value is 9
inside loop x value is 10
outside loop x value is 10

Illustrationsschleife

fn main(){
   //while true

   let mut x = 0;
   loop {
      x+=1;
      println!("x={}",x);

      if x==15 {
         break;
      }
   }
}

Das breakAnweisung wird verwendet, um die Kontrolle aus einem Konstrukt zu entfernen. Wenn Sie break in a loop verwenden, verlässt das Programm die Schleife.

Ausgabe

x=1
x=2
x=3
x=4
x=5
x=6
x=7
x=8
x=9
x=10
x=11
x=12
x=13
x=14
x=15

Erklärung fortsetzen

Die continue-Anweisung überspringt die nachfolgenden Anweisungen in der aktuellen Iteration und bringt die Steuerung zurück zum Anfang der Schleife. Im Gegensatz zur break-Anweisung verlässt die continue die Schleife nicht. Es beendet die aktuelle Iteration und startet die nachfolgende Iteration.

Ein Beispiel für die continue-Anweisung ist unten angegeben.

fn main() {

   let mut count = 0;

   for num in 0..21 {
      if num % 2==0 {
         continue;
      }
      count+=1;
   }
   println! (" The count of odd values between 0 and 20 is: {} ",count);
   //outputs 10
}

Das obige Beispiel zeigt die Anzahl der geraden Werte zwischen 0 und 20. Die Schleife verlässt die aktuelle Iteration, wenn die Zahl gerade ist. Dies wird mit der continue-Anweisung erreicht.

Die Anzahl der ungeraden Werte zwischen 0 und 20 beträgt 10