Wiederholungsanweisungen (for, while, do/while)

In der Programmierung kommt es oft vor, dass Abschnitte im Quelltext wiederholt ausgeführt werden müssen.

Beispiele für Wiederholungen in Computerprogrammen

  • Wiederholung einer Anmeldung bei Eingabe eines falschen Passworts
  • Zählen von Wörtern in einem Text
  • Generieren mehrerer Zufallszahlen (z.B. Würfeln, Lottozahlen, ...)
  • Ausgabe einer Liste von Dateinamen
  • Abholen mehrerer Datenpakete an einer Schnittstelle
  • ...

Wiederholungsanweisungen bzw. Schleifen

Die obigen Beispiele werden im Quelltext mit Wiederholungsanweisungen realisiert. Wiederholungsanweisungen werden auch oft Schleifen genannt. Die folgenden Absätze beschreiben verschiedene Typen von Schleifen, die sich unterschiedlich gut für die obigen Anwendungsfälle eignen.
  • Die so genannten vorprüfenden Schleifen (for, while) prüfen vor der Ausführung des zu wiederholenden Quelltextes die gegebene Bedingung (z.B. ob weitere Dateinamen auszugeben sind).
    StruktElementVorprSchleife.PNG
  • Die so genannte nachprüfende Schleife (do/while) prüft nach der Ausführung des zu wiederholenden Quelltextes die gegebene Bedingung (z.B. ob das Passwort korrekt eingegeben wurde).
    StruktElementNachprSchleife.PNG

Übung

  • Ordnen Sie die obigen Beispiele der vorprüfenden bzw. der nachprüfenden Schleife zu und begründen Sie Ihre Wahl!

Zählen

Wenn etwas wiederholt wird, dann benötigt man oft Zähler. Mit einem Zähler kann man z.B. überprüfen, ob die maximale Anzahl von Anmeldungsversuchen bereits erreicht wurde. Ein Zähler ist eine Variable, welche eine ganze Zahl enthält.
Beispiel für einen Zähler:
var zaehler = 3;
Um solch einen Zähler zu erhöhen (inkrementieren) muss man den Variablenwert ändern, z.B. wie folgt:
// Hier wird der Wert der Variable zaehler ausgelesen,
// eine 1 addiert und das Ergebnis wieder zurückgeschrieben
// in die Variable
zaehler=zaehler+1;
 
// Eine verkürzte Schreibweise, welche das gleiche bewirkt sieht wie folgt aus
zaehler+=1;
 
// Eine weitere Schreibweise, welche den Zähler um 1 erhöht sieht so aus
zaehler++;
 
Um solch einen Zähler zu verringern (dekrementieren) muss man den Variablenwert ändern, z.B. wie folgt:
// Die folgenden drei Anweisungen verringern den Zähler um 1
zaehler--;
zaehler-=1;
zaehler=zaehler-1;
Man kann natürlich auch leicht in anderen Schritten erhöhen oder verringern, z.B. um 2 oder 3:
zaehler+=2;
zaehler-=3;


Die for-Schleife bzw. Zählschleife

Kurzreferenz

// Die For-Schleife hat immer den folgenden Aufbau,
// d.h. sie besteht aus dem Schlüsselwort for, zwei runden
// Klammern in denen drei durch Semicolon getrennte Teile
// stehen und einem Block, welcher ggf. ausgeführt wird
 
for( <Teil1> ; <Teil2> ; <Teil3> )
{
   // der auszuführende Block
   // kann aus beliebig vielen Anweisungen bestehen
}
 
// Teil 1
// wird nur einmal vor Start des ersten Schleifendurchlaufs ausgeführt.
// Hier stehen die für die Schleife zusätzlich benötigten Variablen
// mit Wert, z.B. var i=0
 
// Im Teil 2
// steht eine Bedingung, die bei jedem neuen Durchlauf
// erfüllt sein muss (true), damit der Block erneut ausgeführt wird,
// z.B. i<10
 
// Im Teil 3
// stehen Änderungen, welche nach dem Durchlauf des Schleifenblocks
// vorgenommen werden sollen, z.B. die Erhöhung eines Zählers um 1 => i++

Die for-Schleife bzw. Zählschleife ausführlich (Anleitung zum ausfüllen)

Syntax

for(   ;   ;   )
{
}
Hinweise zur Nutzung der Schleife:
  • Den obigen Text (Syntax der for-Schleife) können ihn immer sofort hinschreiben, wenn Sie wissen, dass es ein paar Anweisungen gibt, welche zu wiederholen sind.

Was wird wiederholt?

for( ; ; )
{
  /* Hier stehen alle Anweisungen, welche wiederholt werden sollen.
     Wenn Sie noch keine Idee haben, wie diese Zeilen genau aussehen,
     dann schreiben Sie am besten erst einmal einen aussagekräftigen
     Kommentar an diese Stelle!
  */
}

Bedingung festlegen

Dann legen wir die Bedingung fest, welche bei jedem Schleifendurchlauf feststellt, ob die Schleife wiederholt werden soll oder nicht. Das kann z.B. x>20 oder y<500 sein oder was Ihnen sonst noch so einfällt. Auch verknüpfte Bedingungen sind möglich wie z.B. (x>20)&&(y<500) etc. (siehe Übungen zu Bedingungen)!
Die Schleife wird wiederholt, wenn die Bedingung wahr ist und abgebrochen, wenn die Bedingung nicht wahr ist.
for( ; /* Bedingung hier einfügen */  ; )
{
 
}
 

Schleifenvariablen ergänzen

Beim Schreiben der Bedingung haben wir gemerkt, welche Variable bzw. Variablen wir für diese Schleife benötigen.
for( /* Hier stehen die in der Schleife verwendeten Variablen oder nichts,
     falls diese bereits vorher angelegt und initialisiert wurden,
     z.B. var i=1 oder var j=100 oder var i=1, j=100 */ ; ; )
{
 
}

Veränderungen nach einem Schleifendurchlauf

Wenn sich die in den Variablen gespeicherten Werte nicht verändern, dann wird die Auswertung der Bedingung immer true bzw. immer false ergeben, d.h. die Schleife wird nie oder endlos ausgeführt. Das bedeutet, das wir die Werte der Schleifenvariablen wahrscheinlich nach jedem Schleifendurchlauf ändern müssen, damit die Bedingung irgendwann einmal zum Abbruch der Schleife führt.
for( ; ; /* Die Änderung der Variablenwerte schreibt man
 jetzt hier hinein, z.B. i++ oder i=i+1 oder i+=1 oder
 j=i-1 oder x=y+5 usw. */ )
{
}
Wenn Sie alles richtig gemacht haben, dann sollte Ihre Wiederholungsanweisung (=Schleife) jetzt funktionieren!

Beispiel "Zähle von 0-9":

for( var i=0; i<10; i++ )
{
  document.write( i + "<br>" );
}
 

Die while-Schleife

Kurzreferenz

Die while-Schleife entspricht im Prinzip der for-Schleife, nur dass Teil 1 und Teil 3 innerhalb der runden Klammern nicht existieren. Auch hier gilt: Die Schleife wird ausgeführt, solange die Bedingung wahr ist!
// Die While-Schleife hat immer den folgenden Aufbau:
 
while( <Bedingung> )
{
   // der auszuführende Block
   // kann aus beliebig vielen Anweisungen bestehen
}
 
// Die Deklaration und Initialisierung der benötigten
// Variablen findet vor der Schleife statt
 
// Die letzte Anweisung innerhalb der Schleife
// enthält z.B. die Erhöhung eines Zählerwerts (o.ä.),
// welcher dann in der Bedingung überprüft wird
 
Beispiel als Pseudocode (d.h. das Programm funktioniert so noch nicht)! :
while( /* Bedingung "Sonnenschein draussen" ist wahr */ )
{
  // Ausgabe: "Nutze das schöne Wetter und gehe spazieren"
}
 
// Ausgabe: "Oh schade, das schöne Wetter ist vorbei"
 

Die do/while-Schleife

Kurzreferenz

Der Quelltext innerhalb der do/while-Schleife wird immer mindestens einmal ausgeführt. Die Bedingung wird am Ende des Schleifensdurchlaufs geprüft. Auch hier gilt: Die Schleife wird ausgeführt, solange die Bedingung wahr ist!
// Die do/while-Schleife hat immer den folgenden Aufbau:
 
do
{
  // der auszuführende Block
  // kann aus beliebig vielen Anweisungen bestehen
 
} while( <Bedingung> );
 
// Die Deklaration und Initialisierung der benötigten
// Variablen findet vor der Schleife statt
 
// Die letzte Anweisung innerhalb der Schleife
// enthält z.B. Änderungen von Variablenwerten,
// welche dann in der Bedingung überprüft werden.
 
 
Beispiel Passwortprüfung als Pseudocode (d.h. das Programm funktioniert so noch nicht)! :
richtigesPasswort = "admin"
 
do
{
  // Aufforderung an Nutzer: "Gib bitte Dein Passwort ein!"
 
} while(    /* Bedingung "Passwort richtig eingegeben" ist wahr,
               wenn das eingegebene Passwort "admin" lautet */    );