*Schleifen
2. while
Im vorherigen Abschnitt bin ich auf die For-Schleife eingegangen. In diesem wollen wir uns die while-Schleife ansehen. In gewisser Weise sind sich beide Schleifen ähnlich. Es ist zT Geschmackssache, welche Schleife man wo verwendet und ich habe da auch noch nicht der Weisheits letzten Schluss gefunden. Man merkt, wenn man mit einer bestimmten Schleife aneckt.
Was sind die Unterschiede zwischen einer For- und While-Schleife?
Die For-Schleife durchläuft ein vorgegebenes Element, eine Schleifenvariable. Das kann zB ein Array sein. Von Anfang bis Ende, oder bis ein bestimmtes Element gefunden wurde und mit break abgebrochen wird. Die While-Schleife hingegen setzt in der Deklaration bereits Grenzen. Sinngemäß bedeutet while
solange diese Bedingung eingehalten wird, mache das was im Schleifeninneren beschrieben ist.
Fangen wir mit einem klassischen Beispiel an. Solange i unter, gleich 10 ist iteriere.
let mut i = 0;
while i <=10{
print!("{} ",i);
i+=1;
}
Was dabei auffällt, die Schleifenvariable i muss bereits im Vorfeld definiert sein. Anderweitig wird der Compiler einen Fehler erzeugen.
Das kann man mit einer For-Schleife auch machen, aber es sieht ein wenig anders aus, wie ihr wisst. Eine weitere Möglichkeit while zu verwenden, ist, die Gültigkeit so lange auf falsch zu setzen bis sie richtig ist.
Wie sieht soetwas aus?
let mut trifft_zu = false;
let mut counter =0;
while !trifft_zu{
counter+=1;
print!("{} ",trifft_zu);
print!("{}",counter);
if counter == 10{
trifft_zu= true;
print!("jetzt haben wir die richtige Zahl erreicht");
}
}
Die Kontrollvariable trifft_zu startet mit false. Gleichzeitig ist ein counter dabei, der die Schritte verdeutlichen soll. Die while-Bedingung heißt dann quasi "mach weiter, solange trifft_zu nicht zutrifft". Es gibt durch den print Befehl jeweils den Counter und false von trifft_zu aus. Solange bis 10 erreicht wurde und trifft_zu zu wahr/true wurde. Hier bricht die Schleife mit der Richtigkeit ab.
Zu guter Letzt schauen wir uns noch die Endlosschleife mit while an. Vielleicht gleich mal der Hinweis, dass wir im nächsten Abschnitt eine Schleife ansehen, die extra als Endlosschleife konzipiert wurde. Früher gab es das noch nicht und man musste sich mit einer while-Endlosschleife begnügen. Also, ein bisschen Nostalgie.
Es gibt 2 Arten, wie so eine Endlosschleife von while aussehen kann.
Die Erste bekommt einfach ein true in die while-Bedingung verankert.
Die Bedingung ist also wahr, weil sie wahr ist. Ein nahezu schon religiöser Charakter.
let mut x:u8 =0;
while true{
println!("x= {}",x);
x+=1;
}
Diese Schleife läuft endlos und zwar in Wiederholung von 0-255, unsigned int 8 bit. Ich hätte ein out_of_range erwartet. Aber nein, die Schleife macht brav weiter.
Die andere Art mit while eine Endlos-Schleife zu erzeugen, besteht darin, eine Situation zu schaffen, wo die true Bedingung durch die Logik bedingt wird. Im folgenden Beispiel passiert es dadurch, dass x >0 bei x+=1 niemals falsch sein kann.
let mut y:u8 = 0;
while y >= 0 {
println!("y = {}", y);
y += 1; // x wird immer größer
}
y gibt hier das selbe aus, wie schon x zuvor und wiederholt sich, bis man abbricht. Wie gesagt, letztlich gibt es für Endlosschleifen eine eigene Art von Schleife. Zum Schluss nochmals der gesamte Code mit der Ausgabe, außer natürlich den Endlosschleifen.
fn main (){
let mut i = 0;
while i <=10{
print!("{} ",i);
i+=1;
}
let mut trifft_zu = false;
let mut counter =0;
while !trifft_zu{
counter+=1;
print!("{} ",trifft_zu);
print!("{}",counter);
if counter == 10{
trifft_zu= true;
print!("jetzt haben wir die richtige Zahl erreicht");
}
}
let mut x:u8 =0;
while true{
println!("x= {}",x);
x+=1;
}
let mut y:u8 = 0;
while y >= 0 {
println!("y = {}", y);
y += 1; // x wird immer größer
}
}
Ausgabe
