Schleifen (for)

Geschichte

Das Konzept der Schleifen in der Programmierung entstand in den 1950er Jahren. Es verbesserte die Bewältigung von repetitiven Aufgaben und wurde erstmals in den Programmiersprachen FORTRAN und ALGOL integriert.

Best Practice

Schleifen eignen sich zum Auslesen von Arrays, beim mehrfachen Ausführen von Prozessen, für Sortieralgorithmen, beim Suchen in Datenstrukturen und vielem mehr.

For Schleife (for-loop)

for (let i = 1; i <= 5; i++) {
    console.log(i); // Ausgabe: 1,2,3,4,5
}

In den runden Klammern gruppieren sich die erforderlichen Parameter für eine iterative Schleife.

1. Initialisierung einer Variable
2. Der Bedingung, die so lange ausgeführt wird, bis sie false ist.
3. Die Iteration. In diesem Fall wird i jeweils um 1 erhöht.

For…in-Schleife

const person = {
    name: "John",
    age: 30,
    city: "New York"
};

for (const key in person) {
    console.log(`${key}: ${person[key]}`);
}

Bei dieser Variante werden nicht die Werte, sondern die Indizes durchlaufen. In den runden Klammern der For-In-Schleife haben wir die Konstante key initialisiert. Dass in bildet den Satz „Schlüssel in Person“, besser verstehen würde man es vielleicht so „Schlüsselwort aus dem Array person“. Arrays bestehen aus Schlüsselwort und Inhalt.

For…of-Schleife

let days: string[] = [
    "Monday", 
    "Tuesday", 
    "Wednesday", 
    "Thursday", 
    "Friday", 
    "Saturday", 
    "Sunday"];

for (let day of days) {
  console.log(day); // Monday, Tuesday, etc.
}

In diesem Beispiel werden die Inhalte aus dem Array days ausgegeben. Die Indizes spielen bei dieser Variante keine Rolle.

Edge Case

Auch wenn wir uns bei der for…in und for..of Schleife nicht so aussieht, als müsste man sich wirklich Sorgen um eine Endlosschleife machen, ist es wichtig sich bei jeder Schleife darüber Gedanken machen. TypeScript kompiliert nun mal nach JavaScript. Sobald der JavaScript-Code auf dem Client landet, nutzt er die Hardware-Ressourcen des Clients. Je nachdem, wie der Algorithmus einer Schleife aussieht bzw. man versehentlich eine Endlosschleife erstellt hat, kann es zum Absturz des Browsers führen. Deshalb sollte man in manchen Fällen zu Unit-Tests greifen.

//Beispiel einer Endlosschleife
export function forLoopFunction(arr: number[], limit: number): number[] {
  let result: number[] = [];
  let i = 0;
  for (i = 0; i < arr.length; i++) {
    if (i === limit) {
	    break;
    }

    if (arr[i] % 2 === 0) {
	    result.push(arr[i]);
	    i--; // Endlosschleife, da i nicht erhöht wird
    }
  }
  return result;
}

In diesem Beispiel haben wir eine for Schleife in der wir i um eins erhöhen, solange die Zahl kleiner arr.length ist. Im ersten if-Block kann die Schleife vorzeitig abgebrochen werden, wenn das limit erreicht wurde. Im zweiten if-Block fügen wir dem Array result ein Element hinzu und reduzieren i um eins. Der Parameter-Array arr braucht nur zwei Einträge, um eine Endlosschleife zu verursachen.

Proof of Concept

Um dir zu zeigen, wie man das Edge Case Beispiel vorzeitig erkennen kann, sehen wir uns den Unit-Test genauer an.

import { forLoopFunction } from './complexLoop';

function testForLoopFunction() {
  const inputArray = [2, 4, 6, 8, 10];
  const limit = 5;
  let result: number[] = [];
  let timeout = false;

  const timer = setTimeout(() => {
    timeout = true;
    console.error("Test failed: Endlosschleife erkannt");
    process.exit(1); // Beendet den Prozess mit Fehlercode
  }, 1000);

  try {
    result = forLoopFunction(inputArray, limit);
  } catch (e) {
    console.error("Fehler während der Ausführung:", e);
  } finally {
    clearTimeout(timer);
  }

  if (!timeout) {
    console.log('Result:', result);
    console.log("Test passed: Keine Endlosschleife");
  }
}

testForLoopFunction();

In der Konstante timer haben wir eine Funktion, die den Test nach einer Sekunde abbrechen soll. Den timer setzen wir in den finally-Block vom try…catch..finally . Sollte es nicht zu einem Catch kommen wird bei einer Endlosschleife finally dafür sorgen, dass die Endlosschleife abgebrochen wird.