**Schleifen**
**3. Loop**

Im Prinzip schon angekündigt, wird sich das Schleifenthema als Haupttrakt mit diesem Abschnitt beenden. *Loop* ist eine Endlosschleife und kann nur durch ein gezieltes *Break* abgebrochen werden.  Es reicht vollkommen aus, den Inhalt von *loop* in geschweifte Klammern zu setzen und schon hört es nicht mehr auf.

```
fn main (){
    loop{
        print!("Endlosschleife - ");
    }
}
```
Ausgabe (Ausschnitt)

![image.png](https://files.peakd.com/file/peakd-hive/jeyf123/23swq4zmShNJe5MkcbLqcL2jVoSkh5cq3n1mYz1zdmEk7EgsE1gFR2J8NQ2x8pGBBa6G5.png)

Das ist natürlich nicht übermäßig nützlich, zeigt aber verkürzt, wie es funktioniert. Was ist aber der Einsatzort einer solchen *Loop-Schleife*?
Kurz gesagt, kann man sie überall dort brauchen, wo ein Programm am Laufen gehalten werden soll. Obwohl ich keine Ahnung von der Entwicklung eines Betriebssystems habe, würde ich davon ausgehen, dass *loop*(s) hier nötig sind, denn ansonsten (nachdem in der Programmierung vorgesehen ist, dass es sich von oben nach unten durcharbeitet), wäre wohl schon bald Schluss, wenn die Basis nicht aufrechterhalten wird. Im Laufe der Zeit werde ich vermutlich auch vermehrt darauf zurückgreifen, aber bis jetzt schreibe ich noch nicht so große Programme, dass ich es brauchen würde ... Aber mal sehen, es ist gut, so etwas in petto zu haben. 

Um auch auf die Iteration einzugehen

```
let mut x=0;
     loop{
         x=x+1;
        print!(" x: {} - ",x);
    }
```
Ausgabe (Ausschnitt)

![image.png](https://files.peakd.com/file/peakd-hive/jeyf123/23swpgUCx94cCEeUieUbQ5xAENCYSRuc4rxaRfN5qgWoJwqaMGJqnrdZcNZwj9NQY4Cf4.png)

Die Bandbreite des *i32* fängt einfach immer wieder von vorne an. Wie bei der *while true* Schleife.

Eine nützliche Besonderheit der *loop*-Schleife möchte ich nicht vorenthalten. Diese lassen sich nämlich auch einen Namen geben. Einfach mit
'name_der_Schleife: loop;' Wenn mehrere *loops* am Laufen sind, können diese durch ihre Namen mit break 'name_der_Schleife abgebrochen werden.

```
    'loop_gesamt: loop{
        println!("Hier beginnen die Geschichten von x und y");
        let mut x =0;
        'loop_x: loop{

            x=x+1;
            if x <=10{
                 println!("{}. x geht noch weiter.",x);
            }
            else{
                println!("Das ist das Ende von x");
                break 'loop_x;
            }
        }

        let mut y =0;
        'loop_y: loop{

            y=y+1;
            if y <=10{
                 println!("{}. y geht noch weiter.",y);
            }
            else{
                println!("Das ist das Ende von y");
                break 'loop_y;
            }

        }

                println!("Das ist das Ende vom Lied von x und y");
                break 'loop_gesamt;

            }
```

Zugegeben, das sieht hier etwas viel aus. Es ist sogar anders, als ich ursprünglich gedacht habe. Bei diesem Beispiel habe ich selbst einiges dazu gelernt. Vor allem in welche Richtungen die Gedanken beim Programmieren laufen sollten. 

*Entspricht das was ich will, dem was ich will?
*Weiß ich etwas nicht, oder ist die Methode falsch, die ich anwende?
*Wenn ich die richtige Methode anwende, warum funktioniert es nicht?
*Sind meine Annahmen über die Methode richtig?

Da gäbe es wahrscheinlich noch ein paar so ähnlich klingende Überlegungen, die allesamt ähnlich klingen, aber trotzdem für einen Zweck essentiell sind.

<u>Also, was macht dieser Codeblock?</u>

In Summe gibt es 3 Endlosschleifen, die per *break* mit dem jeweiligen Schleifennamen abgebrochen werden. 

*loop_gesamt
*loop_x
*loop_y

loop_gesamt bricht ab, wenn die loops von x und y durchgelaufen sind. Im übrigen das letzte Break, darf nicht vor der *println!*-Anweisung stehen, sonst bekommt man diese nie vor Gesicht. 

loop_x lauft bis 10, wird dann abgebrochen und geht weiter auf loop_y. Das widerrum bricht auch bei 10 ab und dadurch geht der Code zum Schleifende von loop_gesamt. Die Ausgabe sieht dann so aus:



![image.png](https://files.peakd.com/file/peakd-hive/jeyf123/23u5XKkMQFeqFzN3R9ykHhW119cjhsUjJqbuRkgQRu5eLa1HZQiHYEmi1zRpGWjG57HZf.png)

Heute kann ich keine gesamte Ausgabe zeigen, weil Endlosschleifen logischerweise dafür nicht geeignet sind. Aber natürlich, wie mein Quellcode aussieht, obwohl er so nicht vernüftig ausführbar wäre.

```
fn main (){
    loop{
        print!("Endlosschleife - ");
    }
    let mut x=0;
     loop{
         x=x+1;
        print!(" x: {} - ",x);
    }


    'loop_gesamt: loop{
        println!("Hier beginnen die Geschichten von x und y");
        let mut x =0;
        'loop_x: loop{

            x=x+1;
            if x <=10{
                 println!("{}. x geht noch weiter.",x);
            }
            else{
                println!("Das ist das Ende von x");
                break 'loop_x;
            }
        }

        let mut y =0;
        'loop_y: loop{

            y=y+1;
            if y <=10{
                 println!("{}. y geht noch weiter.",y);
            }
            else{
                println!("Das ist das Ende von y");
                break 'loop_y;
            }

        }

                println!("Das ist das Ende vom Lied von x und y");
                break 'loop_gesamt;

            }

    }





```

![13.png](https://files.peakd.com/file/peakd-hive/jeyf123/Eo2BpKHNVyKHMMX3WugfS2Xx3uXLoHCmQrsPtdgVJn2k5M2dvwFT2nnph4pvoUwAenj.png)