Reflexionen über die Programmiersprache Rust 11

Schleifen

1. For-Schleife

Bevor wir bei den Datentypen weitermachen, vorher ein Ausreißer in die Welt der Schleifen von Rust.

Wozu sind Schleifen gut?
Vereinfacht ausgedrückt, sollen sie einem die Arbeit abnehmen, bei einem Durchlauf von Daten den man manuell programmieren müsste. Diesen Durchlauf nennt man auch Iteration (also, wenn ihr wo iter lest, das kommt daher)

Welche Schleifen gibt es in Rust?
Neben der For-Schleife, gibt es in Rust auch noch eine While-Schleife und als besondere Eigenheit von Rust eine Loop-Schleife.

Wie ist die For-Schleife aufgebaut?

for variable Bedingung{
    was soll mit der Bedingung werden?
}

Die Variable hinter for ist für den Durchlauf der Bedingung wichtig und Pflicht. Sie kann jeden Namen haben, meistens beschränkt man sich aber auf einen einzelnen Buchstaben. In ihr werden die Daten für die Verarbeitung und Ausgabe gespeichert.

zählt von 1 bis 10

for x in 1..=10{
        print!("{} ",x);
    }

zählt a von 6-10

let a = 5;
    for a in a..10 {
        print!("{} ",a);
    }

Iteration über ein Array

let b = [1,17,23,15,12,4];
    for i in b{
        print!("b={} ",i);
    }

Prüfen, ob es eine bestimmte Stelle in diesem Array gibt

for x in b{
        print!("b={} ",x);
        if x == 12{
            println!("Die 12 wurde gefunden");
            break;
        }
        else{
            println!("weiter");
        }

    }

Ausgabe

Das hat ein wenig Erklärungsbedarf.Also, b wird durch x iteriert. Die Zahlen die wir vorher im b [array] hatten [1,17,23,15,12,4] gehen durch die Schleife. Das Besondere dabei ist, dass nach der 12 gesucht wird. In der Ausgabe sehen wir, alle Werte die nicht 12 sind, werden als else gewertet und das Programm gibt "weiter" aus. Bis zum Punkt (die vorletzte Stelle), wo tatsächlich 12 ist. Hier passiert die Ausgabe, "Die 12 wurde gefunden". Die 4 dahinter wird ignoriert. Das break sorgt dafür, dass die Schleife an diesem Punkt abgebrochen wird und das Programm am nächsten Einstiegspunkt weitermacht.

Mehrere Variablen mit einer Aufgabe durch die Schleife schicken

let mut  a=0;
let mut b =0;
for  x in 1..=10{
        a+=1;
        b=a*2;

        print!("a.{} ",a);
        print!("b.{} ",b);
    }

Das ist glaub ich ein guter Ansatz, wenn wir dann noch die verschachelte For-Schleife anschauen wollen. Vor allem ist der Unterschied deutlicher erkennbar. Was macht diese Schleife/Programm?

*Als erstes werden die Variablen a und b deklariert. Sie sind mut, dh. sie sind dafür vorgesehen sich später zu ändern. Die For-Schleife startet mit x in 1..=10. Bedeutet, die Aufgabe von x wiederholt sich 10 mal. Im Inneren dieser Schleife wird als erstes festgelegt, wie sich die Werte von a und b ändern sollen. a wird um 1 erhöht (a war ja ursprünglich 0) und b verdoppelt den Wert von a.

Was würde passieren, wenn wir a und b erst innerhalb der Schleife deklarieren würden? Ich zeigs mal und ihr könnt euch Gedanken machen, bevor ihr die Ausgabe anschaut.

for  x in 1..=10{
        let mut  a=0;
        let   mut b =0;//a und b werden innerhalb der Schleife deklariert
        a+=1;
        b=a*2;
        print!("a.{} ",a);
        print!("b.{} ",b);
    }

Ausgabe

Hättet ihr damit gerechnet?

Zur Erklärung was passiert ist. Anstatt die beiden Variablen außerhalb der For-Schleife zu schreiben, stehen sie diesmal im Inneren. Das hat zur Folge, dass jedesmal wenn die Schleife in eine neue Iteration wechselt, a und b wieder bei 0 beginnen. Im wahrsten Sinn des Wortes. Deshalb kommt a nicht über 1 und b nicht über 2 hinaus.

Verschachtelte Schleifen
Lasst uns jetzt die mal anschauen. Was machen die und wozu sind sie gut?
Das Grundgerüst einer verschachtelten Schleife sieht so aus.

for äußere_Schleife ...{
    blabla...
    for innere_Schleife{
        blabla..
            }
                }

Am Wichtigsten ist wahrscheinlich in welcher Reihenfolge die Schleifen abgearbeitet werden. Gedanklich hilft es mir eine Uhr vorzustellen. Stunden und Minutenzeiger (2 Schleifen). Der Stundenzeiger ist die äußere Schleife, der Minutenzeiger die Innere. Also bleibt der Stundenzeiger solange stehen, bis 60 Minuten der inneren Schleife vergangen sind. Danach schaltet er 1 Einheit weiter.

for mut std in 0..=23 {
        std+=1;
        if std <=23{


            for mut min in 0..=59 {
            min+=1;
            if min <=59{

            for mut sek in 0..=59 {
            sek+=1;
            if sek <=59{

        print!("\t\t{std}:");
        print!("{min}:");
        println!("{sek}:");
        }

    }

Was passiert in diesen 3 verschachtelten Schleifen? Alle 3 Schleifen sind mit mut initialisiert, denn sie müssen die Zeit raufzählen. Alle 3 Schleifen werden mit einer If-Bedingung verknüpft, die besagt, solange der Wert unter der Wiederholunsfrequenz des Zeitintervalls liegt, zähle je eine Stufe nach oben. Falls sich jemand fragt, warum die print Anweisungen erst am Ende stehen, innerhalb der letzten If-Anweisung, das bereitet mir immer wieder etwas Kopfschmerzen, aber es wird besser. Der Grund dafür ist, weil wie im vorherigen Beispiel die Position ebenfalls entscheidend ist. Würden die print-Anweisungen zB ganz am Anfang stehen, gäbe es die Variablen noch gar nicht. Stünden sie jeweils in der passenden Schleife, wären die Zahlenkolonnen für sich einzeln. Davon wollte ich ein Video machen, aber es dauert nur 6 tausendstel Sekunden. Ich hab es massiv verlangsamt und als GIF gespeichert. Viel sehen tut man nicht dabei.

Zum Schluss kommt wieder die Zusammenfassung zum Kopieren und die Ausgabe (ohne Uhrzeit)

Ausgabe