While-Loops R: While-Schleifen in R

Schleifen sind eines der Basiskonzepte der Programmierung. Sie sorgen für die wiederholte Ausführung bestimmter Codestellen unter einer bestimmten Bedingung. Mit While-Schleifen in R wird ein Programmabschnitt so lange wiederholt, bis die zuvor spezifizierte Bedingung zu falsch auswertet.

Wofür werden While-Schleifen in R eingesetzt?

While-Schleifen werden für die wiederholte Ausführung von Programmcode in Abhängigkeit einer Bedingung genutzt. Solange diese Bedingung zutrifft, wird der im Codeblock der While-Schleife platzierte Code ausgeführt.

Schleifen werden in der R-Programmierung häufig eingesetzt, um über Elemente einer R-Liste zu iterieren und dann bestimmte Operationen für jedes Element dieser Liste einzeln auszuführen. So können Sie aus einer Liste von R-Strings beispielsweise jeden String auf dem Bildschirm ausgeben lassen. Aber auch für die bedingte Ausführung von Code werden While-Loops in R genutzt. Außerdem sind Schleifen wie die While-Loop die Basis für die Implementierung vieler bekannter Sortieralgorithmen, die einen Datenbestand nach bestimmten Kriterien ordnen.

Aufbau und Syntax von While-Loops in R

Die Syntax von While-Loops in R ähnelt dem Aufbau von While-Schleifen in den meisten anderen Programmiersprachen. Im Schleifenkopf, der mit dem Schlüsselwort while eingeleitet wird, wird in runden Klammern die Bedingung angegeben. Letztere muss wahr sein, damit der Schleifenrumpf ausgeführt wird. Dieser Rumpf ist nichts weiter als ein eigener Codeblock nach dem Schleifenkopf, umschlossen von geschweiften Klammern.

Um sich die Syntax zu veranschaulichen, ist ein Beispiel hilfreich. Das folgende R-Loop-Beispiel zeigt eine While-Schleife, die die Werte von 1 bis 10 ausgibt:

x <- 1
while (x <= 10) {
    print(x)
    x <- x + 1
}

Beipiel: Bubblesort in R

Bubblesort ist ein klassischer Sortieralgortihmus, der genutzt wird, um Elemente eines R-Vektors oder eines Arrays in R aufsteigend zu sortieren. In diesem Sortieralgorithmus wird eine While-Schleife eingesetzt, um den Sortiercode so lange auszuführen, bis alle Elemente des Vektors sortiert sind:

bubblesort <- function(x) {
    swapped <- TRUE
    n <- length(x) - 1
    while (swapped) {
        swapped <- FALSE
        for (i in 1:n) {
            if (x[i] > x[i+1]) {
                tmp <- x[i]
                x[i] <- x[i+1]
                x[i+1] <- tmp
                swapped <-TRUE
                }
        }
    }
    return(x)
}

Im obigen Code wird eine R-Funktion namens bubblesort erstellt. Diese sorgt dafür, dass ein numerischer Vektor aufsteigend sortiert wird. Die While-Schleife wird eingesetzt, um das Tauschverfahren, das für Bubblesort wesentlich ist, so lange durchzuführen, bis die Sortierung abgeschlossen ist.

Break aus While-Loop in R

Um eine While-Loop unter einer bestimmten Bedingung vorzeitig zu verlassen, können Sie das Schlüsselwort break nutzen. Dieses sorgt dafür, dass die Schleife verlassen und nicht wieder betreten wird. Ein Beispiel für die Anwendung von break erläutert das Prinzip:

x <- 10
while (x >= 0) {
    print(x)
    if (x == 5) {
        break
        }
        x <- x - 1
}

Die obige Schleife gibt die Zahlen von 10 bis 5 auf dem Bildschirm aus. Wenn die Variable x den Wert 5 erreicht, wird die R-if-Bedingung ausgeführt und die Schleife durch den Aufruf von break vorzeitig beendet.

Andere Schleifen in R

Die R-While-Loop ist nicht die einzige Form von Schleifen in R. Neben ihr existieren die For-Schleife, die häufig als eine Art Zählschleife angesehen wird, sowie die Repeat-Schleife, die dazu dient, Code unabhängig von einer Bedingung mehrfach auszuführen. Repeat-Schleifen müssen mit dem Schlüsselwort break verlassen werden, ansonsten handelt es sich bei ihnen um Endlosschleifen.

For-Schleife in R

For-Schleifen werden dann genutzt, wenn die Anzahl an Iterationen im Vorhinein bekannt ist. Die Anzahl der Iterationen wird explizit im Schleifenkopf angegeben. Eine For-Schleife, die die Zahlen von 1 bis 5 ausgibt, sieht wie folgt aus:

for (z in 1:5) {
print(i)
}

Repeat-Schleife in R

Repeat-Loops in R werden genutzt, um Code unabhängig von einer Bedingung mehrfach auszuführen. Wenn Sie nicht gerade erst das Programmieren erlernen, kennen Sie vermutlich Do-While-Loops aus anderen Programmiersprachen wie Java. Eine explizite Do-While-Loop in R, bei der ein Codeblock mindestens einmal ausgeführt wird, gibt es nicht. Die Funktionalität kann mit Repeat-Schleifen allerdings einfach implementiert werden:

x <- 1
repeat {
    print(x)
    if (x >= 10) {
        break
        }
x <- x + 1
}

Das obige Codebespiel gibt die Zahlen von 1 bis 10 aus dem Bildschirm aus. Der Code, der mindestens einmal ausgeführt werden soll (und der in einer klassischen Do-While-Loop im „Do-Codeblock“ stünde), wird vor dem if-Statement ausgeführt, das die Schleife beendet, wenn die angegebene Bedingung zutrifft.