Die If-Schleife in der praktischen Anwendung

Es gibt sie doch, die If-Schleife – oder etwa nicht?

Viele Leute fragen sich: Was ist und was macht eigentlich die If-Schleife, die verbotene Anweisung der Informatik? Die Antwort wird Sie verblüffen!

Vielleicht haben Sie auch schon von der If-Schleife gehört, jenem ominösen Konstrukt, das ähnlich wie sehr helle Töne, nur von jungen Informatik-Anfängerninnen wahrgenommen werden kann, jedoch erfahrenen und älteren Programmier-Experteninnen, Informatik-Professoreninnen und Informatik-Turoreninen tragisch verborgen bleibt; ja dessen Existenz sogar verleugnet wird.

Vielleicht gehören Sie selbst zu den Informatik-Anfängerninnen und fragen sich, warum die If-Schleife vom Establishment der Informatik ins schlechte Licht gerückt wird. Vielleicht gehören Sie selbst zum abgehobenen Informatik-Establishment und suchen wieder Kontakt zum kleinen Mann, zu Jederfrau und allgemein-mensch.

Sie werden feststellen, dass diese Seite nicht diskriminiert und nur der Wahrheit über die If-Schleife verpflichtet ist, so wie diese sich dem offenherzigen Informatik-begeisterten Menschen darstellt.

Was Programmier-Anfänger_innen unter einer If-Schleife verstehen

Programme sind zunächstmal Abfolgen von Anweisungen, die trivialerweise nacheinander ausgeführt werden. Ein solches, rein lineares Programm kann jedoch nicht auf Veränderungen reagieren, sondern spult immer nur die immer gleiche Abfolge von Befehlen ab.

Damit ein Programm mehr kann, gibt es neben reinen Befehlen in Programmiersprachen die Möglichkeit, Zustände in Form von Daten zu speichern, dann an späterer Stelle im Programmablauf auf diese Zustände zu reagieren und in Abhängigkeit von diesen Zuständen den Programmablauf zu verändern.

Früher wurde dies durch das heute gesetzlich verbotene „Goto” („Gehe zu”) realisiert, mit dem an eine andere Stelle des Ablaufs des Programms gesprungen und dort weitergemacht werden kann. Da dieses „Goto” aber in unserer zivilisatorisch fortgeschrittenen Kultur heute nicht mehr erlaubt ist, wird auf das so-genannte „strukturierte Programmieren” zurückgegriffen. Hierbei werden die besten der früher gebräuchlichen Nutzungen des frei und ohne Einschränkung verwendbaren „Goto” in neue, starre Konstrukte übertragen.

Die wichtigsten dieser Konstrukte sind Funktionen/Prozeduren, Schleifen und Abfragen. Allen ist im wesentlichen gemein, dass eine Abfolge von Anweisungen in Blöcke zusammengefasst werden, die als ganzes, ja als Gruppe ausgeführt werden sollen. Bei vielen Programmiersprachen werden diese Blöcke über ein Umgeben der Anweisungsfolge mit einer einleitenden Geschweiften Klammer { und einer ausleitenden Geschweiften Klammer } zusammengefasst. Hierdurch ähneln sich diese Konstrukte rein visuell aufgrund der Klammerung mit den sonst selten gebräuchlichen Klammern stark.

Informatik-Anfängerinnen lernen dann die if-Anweisung, die for-Schleife, die while-Schleife und weitere syntaktische Anweisungen in ihren ersten Begegnungen mit der Informatik kennen. Heutige Schleifenkonstrukte beinhalten meist die Überprüfung einer Bedingung, um den Durchlauf ihrer Schleife beeinflussbar zu gestalten. Da eine If-Anweisung syntaktisch den gleichen optischen Eindruck wie diese Schleifen vermittelt, eine Überprüfung einer Bedingung entfälft und mittels der Geschweiften Klammern geklammert wird, zählen Jung-Programmiererinnen die if-Anweisung in ihrer Vorstellung zu der gedanklichen Klasse der Schleifen. Hier zählt der Eindruck und nicht die Quintessenz.

In dem Sinne ist die If-Schleife für junge Studenteninnen eine Schleife, deren durch Geschweifte Klammern umgebener Schleifenkörper genau einmal ausgeführt wird, wenn ihre zugeordnete Bedingung wahr ist – sie kann sich nie wiederholen und ist somit keine Schleife. Oder doch?

Hier ein Beispiel wie eine If-Schleife (von der Struktur her) für junge Informatiker_innen aussieht:

gobbelgobbel(gobbel === bobbelmobbel) {
    mobbel("ist wahr")
}

… und hier ein Beispiel wie eine while-Schleife (von der Struktur her) für junge Informatiker_innen aussieht:

gobbelgobbel(gobbel === bobbelmobbel) {
    mobbel("ist wahr")
}

Sind unterschiedliche Dinge, machen genaugenommen etwas anderes, aber sehen gleich aus, fragen eine Bedingung ab und führen dann ihren Schleifenkörper kein, ein oder mehrmals aus... Und das ist der Grund für die Existenz der Nichtexistenz der If-Schleife!

Aber was ist, wenn wir mit einer If-Schleife eigentlich etwas ganz anderes meinen? Kann eine If-Schleife eine Realisierung einer If-Anweisung mit Hilfe einer Schleife sein? Die Antwort ist ja, denn im Kern sind die Schleifen alle über ein If und ein Goto implementiert, sofern es sich nicht um rekursive Konstrukte handelt, die lieber im Bereich des Lambda-Kalkulus geblieben wären.

Möglichkeiten, ein If über Schleifen zu realisieren…

Es gibt letztlich sehr viele Möglichkeiten ein If-Schleifen-ähnliches Konstrukt zu realisieren. Der Einfachheit halber wählen wir hier Beispiele, die mittels Equivalienzvergleich überprüfen sollen, ob die Variable x den Wert 5 enthält. Falls dies der Fall ist, die Bedingung also wahr ist, soll der Block des Schleifenkörpers genau einmal ausgeführt werden.

Eine If-Schleife mit For

Das for-Schleifenkonstrukt kann drei syntaktische Anweisungen erhalten, von denen wir aber nur eines brauchen, um unsere If-Schleife zu realisieren.

Die erste Anweisung kann Variablen indizieren. Wir benötigen keine Variablen für diesen Ansatz, daher kann die erste Anweisung leer bleiben. Dies ist syntaktisch erlaubt.

Der zweite Eintrag enthält eine Bedingung. Solange diese Bedingung wahr ist, wird der Block der for-Schleife ausgeführt. Dies ziehen wir geschickt heran, um die Bedingung unserer If-Schleife zu realisieren.

Der dritte Eintrag enthält eine Anweisung, mit der üblicherweise eine Variable modifiziert wird, beispielsweise kann hier eine Laufvariable hochgezählt werden. Wir benötigen auch dies für unseren Ansatz nicht und daher kann der dritte Eintrag leer bleiben.

Die for-Schleife wiederholt den Block des Schleifenkörpers so lange, wie die Bedingung im zweiten Eintrag wahr ist. Wir wollen aber für unsere If-Schleife nur genau eine Ausführung. Zu diesem Zweck fügen wir am Ende des Schleifenkörper-Blocks eine break-Anweisung ein, mit dem die gesamte for-Schleife verlassen wird.

Somit wäre die If-Schleife unter der Zuhilfenahme des for-Schleifen-Konstrukts realisiert:

for(; x == 5;) {
    print("Bedingung ist wahr.")
    break
}

Die simple Variante eine If-Schleife über eine while-Schleife zu realsieren

Das while-Schleifenkonstrukt erhält einen syntaktische Ausdruck, nämlich eine Bedingung. Solange diese Bedingung wahr ist, wird der Block des while-Schleifenkörpers ausgeführt. Ob die Bedingung wahr ist, wird vor jedem Durchlauf des Blocks des Schleifenkörpers überprüft. Trivialerweise ist dies bereits fast schon eine If-Schleife.

Die while-Schleife wiederholt ähnlich wie die for-Schleife den Block des Schleifenkörpers so lange, wie die Bedingung im Eintrag wahr ist. Wir wollen aber für unsere If-Schleife wieder nur genau eine einzige Ausführung, für den Fall, dass die Bedingung wahr ist. Erneut können wir hierfür am Ende des Blocks eine break-Anweisung einfügen. Hierüber wird die gesamte while-Schleife verlassen und garantiert, dass unsere Anweisungen im Schleifenkörper nur maximal einmal dann ausgeführt, werden, wenn die Bedingung zutraf.

while(x == 5) {
    print("Bedingung ist wahr.")
    break
}

Über die Möglichkeit eine If-Schleife mittels einer do…while-Schleife zu implementieren

Das do…while-Schleifenkonstrukt erhält einen syntaktische Ausdruck, nämlich eine Bedingung. Solange diese Bedingung wahr ist, wird der Block des do…while-Schleifenkörpers ausgeführt. Allerdings wird – anders als bei der while-Schleife – die Bedingung erst am Ende auf wahr-heit überprüft. Dies stellt uns vor eine Herausforderung.

Hier ein illustratives und illustres Beispiel für eine do…while-Schleife, die , falls die Bedingung wahr ist, andauernd den Bestätigungstext ausgibt, aber nie damit aufhört:

do {
    print("Bedingung ist wahr.")
} while (x == 5);

Würden wir hier wieder unseren Trick mit der break-Anweisung versuchen, so müssten wir feststellen, dass die Anweisungen im Block des do…while-Schleifenkörpers ausgeführt werden, selbst wenn die Bedingung nicht wahr ist. Dies Verhalten zeigt sich, da die do…while-Schleife die Anweisungen in dem Block des Schleifenkörpers immer mindestens einmal ausführt, bevor die Bedingung überhaupt überprüft wird.

Hier müssten wir uns eigentlich geschlagen geben, denn mit dieser einfachen Variante können wir unsere If-Schleife nicht implementieren. Aber… viele Probleme, von denen man erst denkt, man könne sie nicht so einfach lösen, können mit etwas mehr Komplexität und Ineleganz doch gelöst werden:

do {
    for(;x == 5;) {
        print("Bedingung ist wahr.")
    }
    break;
} while ();

Lambda-Kalkühl

Im Lambda-Kalkühl müssen If-Schleifen natürlich rekursiv durch Funktionen implentiert werden. Da dies trivialerweise nicht anders geht, wird die Implementierung dem geneigten Leserin als Fingerübung überlassen.

Copystreit 2019-08-11. Das vorliegende Dokument wurde von Hand erstellt und ist auch mit Unterschrift ungültig.