Die for-Schleife - entstanden aus Frust

Die "for"-Schleife ist ein grundlegendes Konzept in der Programmierung und stammt aus den 1950er Jahren, als sie in der Programmiersprache FORTRAN eingeführt wurde. FORTRAN, ein Akronym für "FORmula TRANslation", wurde entwickelt, um numerische Berechnungen und wissenschaftliches Rechnen zu vereinfachen. Die "for"-Schleife bot einen Mechanismus zur Durchführung wiederholter Berechnungen.

Eine interessante Anekdote rund um die "for"-Schleife – oder genauer gesagt, um die Programmiersprache, in der sie ihren Ursprung hat – bezieht sich auf ihre Entstehung. Die "for"-Schleife wurde erstmals in der Programmiersprache FORTRAN eingeführt, die in den 1950er Jahren von IBM entwickelt wurde. Der Name FORTRAN steht für "Formula Translation" und wurde entwickelt, um den Bedarf an einer effizienteren Programmiersprache zu decken, die sich gut für wissenschaftliche und ingenieurtechnische Berechnungen eignet.

Die Anekdote hierbei ist, dass John Backus, der Leiter des IBM-Teams, das FORTRAN entwickelte, eigentlich kein großer Fan von Programmierung war. Tatsächlich sah er Programmierung als ermüdend und frustrierend an, und sein Hauptziel bei der Entwicklung von FORTRAN war es, den Prozess zu vereinfachen und zu automatisieren, damit er weniger Zeit mit Programmieren verbringen musste.

Das mag auf den ersten Blick paradox erscheinen – jemand, der Programmieren nicht mochte, entwickelt eine der einflussreichsten Programmiersprachen aller Zeiten –, aber es zeigt, dass manchmal die besten Innovationen aus der Notwendigkeit heraus entstehen. Und ohne Frage hat die Einführung der "for"-Schleife in FORTRAN den Weg für viele nachfolgende Verbesserungen in der Programmierung geebnet.

Struktur und Funktionsweise einer "for"-Schleife

Im Allgemeinen besteht eine "for"-Schleife aus drei Teilen: der Initialisierung, der Bedingung und der Inkrementierung. Hier ist der typische Aufbau:

for (Initialisierung; Bedingung; Inkrementierung) {
  // Der hier stehende Code wird wiederholt ausgeführt
}

Initialisierung: Hier definierst du eine Zählvariable und gibst ihr einen Anfangswert. Dies geschieht nur einmal vor dem Start der Schleife.

Bedingung: Hier schreibst du einen Ausdruck hin, der entweder wahr oder falsch ist. Solange dieser Ausdruck wahr ist, wird die Schleife fortgesetzt. Sobald der Ausdruck falsch wird, endet die Schleife.

Inkrementierung: Hier änderst du den Wert der Zählvariable bei jedem Durchlauf der Schleife. Normalerweise erhöhst du den Wert, aber es ist auch möglich, ihn zu vermindern.

Vor- und Nachteile der "for"-Schleife

Einer der großen Vorteile einer "for"-Schleife ist ihre Klarheit und Lesbarkeit. Im Vergleich zu anderen Schleifentypen sind alle wichtigen Komponenten der Schleife - die Initialisierung, die Bedingung und die Inkrementierung - an einem einzigen Ort zu finden. Diese Struktur bietet einen klaren Überblick über den Steuermechanismus der Schleife, wodurch sie intuitiver und leichter zu verstehen ist.

Zusätzlich bietet die "for"-Schleife eine bemerkenswerte Kontrolle über den Schleifendurchlauf. Du kannst genau festlegen, wie viele Durchläufe die Schleife machen soll. Dies ist besonders nützlich, wenn du eine bestimmte Anzahl von Operationen durchführen musst und du im Voraus weißt, wie viele Durchläufe dafür erforderlich sind.

Ein weiterer Vorteil ist ihre Flexibilität. Die "for"-Schleife kann leicht an die spezifischen Anforderungen deines Programms angepasst werden. Mit einer geschickten Auswahl der Initialisierung, Bedingung und Inkrementierung kannst du die Schleife so konfigurieren, dass sie genau das tut, was du für dein Programm brauchst.

Trotz dieser Vorteile gibt es auch einige Nachteile, die berücksichtigt werden müssen. Einer davon ist die Möglichkeit von Endlosschleifen. Wenn die Bedingung der Schleife immer wahr ist und du nicht vorsichtig genug bist, kann die Schleife endlos laufen. Dies kann dazu führen, dass dein Programm hängt oder mehr Ressourcen verbraucht als notwendig.

Ein weiterer Nachteil ist die Komplexität, die mit umfangreichen oder stark verschachtelten Schleifen einhergehen kann. Bei komplexen Schleifen kann der Code schnell unübersichtlich und schwierig zu verstehen werden. Dies kann zu Fehlern führen und die Wartung des Codes erschweren.

In diesem Kontext sieht eine typische "for"-Schleife so aus:

for (int i = 0; i < 10; i++) {
  // Code, der 10 Mal ausgeführt wird
}

Heutzutage ist die "for"-Schleife ein unverzichtbares Werkzeug in nahezu jeder modernen Programmiersprache und findet Anwendung in den unterschiedlichsten Bereichen, von Webentwicklung und Datenanalyse bis hin zu Hardwareprogrammierung auf Mikrocontrollern wie dem Arduino. Sie ist ein elementares Konzept, das jeder Programmierer verstehen und anwenden können sollte.

In dem gegebenen Beispiel beginnst du zunächst mit der Definition einer Variablen, die du "i" nennst. Du weist dieser Variable den Anfangswert 0 zu, dies ist der erste Schritt und wird als Initialisierung bezeichnet. Die Initialisierung findet vor dem Start des ersten Durchlaufs statt und dient dazu, den Startpunkt der Schleife festzulegen.

Der nächste Schritt ist die Festlegung einer Bedingung, die bestimmt, wann die Schleife beendet wird. In diesem Fall hast du festgelegt, dass die Schleife solange fortgesetzt werden soll, wie der Wert von "i" kleiner als 10 ist. Diese Bedingung wird vor jedem Durchlauf der Schleife überprüft. Ist die Bedingung erfüllt, wird der Schleifendurchlauf ausgeführt, andernfalls wird die Schleife beendet.

Der dritte Schritt ist die Inkrementierung. Nach jedem Durchlauf der Schleife erhöhst du den Wert von "i" um 1. Dies dient dazu, die Schleife voranzutreiben und dafür zu sorgen, dass sie sich schließlich der Bedingung nähert, die ihre Beendigung veranlasst.

Schließlich ist der Code, den du innerhalb der geschweiften Klammern platzierst, das Herzstück deiner Schleife. Dieser Codeblock wird bei jedem Durchlauf der Schleife ausgeführt. In diesem Fall wird er insgesamt 10 Mal ausgeführt, wobei der Wert von "i" bei jedem Durchlauf um 1 erhöht wird. Durch die Kombination von Initialisierung, Bedingung und Inkrementierung kannst du präzise steuern, wie und wann dieser Codeblock ausgeführt wird.

Einfaches Beispiel mit Serial

In diesem Beispiel sendet die Arduino-Platine die Zahlen von 0 bis 9 über die serielle Schnittstelle an deinen Computer, wobei jede Zahl eine Sekunde nach der vorherigen gesendet wird.

void setup() {
  // Öffnen der seriellen Kommunikation mit einer Baudrate von 9600
  Serial.begin(9600);
}

void loop() {
  for (int i = 0; i < 10; i++) {
    // Senden der Zahl i über die serielle Schnittstelle
    Serial.println(i);
    delay(1000); // Warten von einer Sekunde
  }
}

Sketch-Details und Erläuterungen

Hier wird eine "for"-Schleife gestartet. Eine Zählvariable "i" wird initialisiert und auf 0 gesetzt. Solange "i" kleiner als 10 ist, wird der Code in der Schleife ausgeführt und "i" wird nach jedem Durchlauf um 1 erhöht.

In dieser Zeile wird der aktuelle Wert von "i" an den Computer gesendet, gefolgt von einem Zeilenumbruch (durch println). Dies führt dazu, dass die Zahlen 0 bis 9 nacheinander in der seriellen Konsole ausgegeben werden.

for (int i = 0; i < 10; i++) 
{
 ...
}

Diese Zeile sorgt dafür, dass das Programm für 1000 Millisekunden (1 Sekunde) angehalten wird. Dies sorgt dafür, dass zwischen der Ausgabe jeder Zahl eine Verzögerung von 1 Sekunde besteht.

delay(1000);