While-Loops R: While-Schleifen in R

Schleifen sind eines der Ba­sis­kon­zep­te der Pro­gram­mie­rung. Sie sorgen für die wie­der­hol­te Aus­füh­rung be­stimm­ter Code­stel­len unter einer be­stimm­ten Bedingung. Mit While-Schleifen in R wird ein Pro­gramm­ab­schnitt so lange wie­der­holt, bis die zuvor spe­zi­fi­zier­te Bedingung zu falsch auswertet.

Wofür werden While-Schleifen in R ein­ge­setzt?

While-Schleifen werden für die wie­der­hol­te Aus­füh­rung von Pro­gramm­code in Ab­hän­gig­keit einer Bedingung genutzt. Solange diese Bedingung zutrifft, wird der im Codeblock der While-Schleife plat­zier­te Code aus­ge­führt.

Schleifen werden in der R-Pro­gram­mie­rung häufig ein­ge­setzt, um über Elemente einer R-Liste zu iterieren und dann bestimmte Ope­ra­tio­nen für jedes Element dieser Liste einzeln aus­zu­füh­ren. So können Sie aus einer Liste von R-Strings bei­spiels­wei­se jeden String auf dem Bild­schirm ausgeben lassen. Aber auch für die bedingte Aus­füh­rung von Code werden While-Loops in R genutzt. Außerdem sind Schleifen wie die While-Loop die Basis für die Im­ple­men­tie­rung vieler bekannter Sor­tier­al­go­rith­men, die einen Da­ten­be­stand nach be­stimm­ten 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 Pro­gram­mier­spra­chen. Im Schlei­fen­kopf, der mit dem Schlüs­sel­wort while ein­ge­lei­tet wird, wird in runden Klammern die Bedingung angegeben. Letztere muss wahr sein, damit der Schlei­fen­rumpf aus­ge­führt wird. Dieser Rumpf ist nichts weiter als ein eigener Codeblock nach dem Schlei­fen­kopf, um­schlos­sen von ge­schweif­ten Klammern.

Um sich die Syntax zu ver­an­schau­li­chen, 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: Bubble­sort in R

Bubble­sort ist ein klas­si­scher Sor­tier­al­g­or­tih­mus, der genutzt wird, um Elemente eines R-Vektors oder eines Arrays in R auf­stei­gend zu sortieren. In diesem Sor­tier­al­go­rith­mus wird eine While-Schleife ein­ge­setzt, um den Sor­tier­code so lange aus­zu­füh­ren, 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 bubble­sort erstellt. Diese sorgt dafür, dass ein nu­me­ri­scher Vektor auf­stei­gend sortiert wird. Die While-Schleife wird ein­ge­setzt, um das Tausch­ver­fah­ren, das für Bubble­sort we­sent­lich ist, so lange durch­zu­füh­ren, bis die Sor­tie­rung ab­ge­schlos­sen ist.

Break aus While-Loop in R

Um eine While-Loop unter einer be­stimm­ten Bedingung vorzeitig zu verlassen, können Sie das Schlüs­sel­wort 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 Bild­schirm aus. Wenn die Variable x den Wert 5 erreicht, wird die R-if-Bedingung aus­ge­fü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 exis­tie­ren die For-Schleife, die häufig als eine Art Zähl­schlei­fe angesehen wird, sowie die Repeat-Schleife, die dazu dient, Code un­ab­hän­gig von einer Bedingung mehrfach aus­zu­füh­ren. Repeat-Schleifen müssen mit dem Schlüs­sel­wort break verlassen werden, ansonsten handelt es sich bei ihnen um End­los­schlei­fen.

For-Schleife in R

For-Schleifen werden dann genutzt, wenn die Anzahl an Ite­ra­tio­nen im Vorhinein bekannt ist. Die Anzahl der Ite­ra­tio­nen wird explizit im Schlei­fen­kopf 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 un­ab­hän­gig von einer Bedingung mehrfach aus­zu­füh­ren. Wenn Sie nicht gerade erst das Pro­gram­mie­ren erlernen, kennen Sie ver­mut­lich Do-While-Loops aus anderen Pro­gram­mier­spra­chen wie Java. Eine explizite Do-While-Loop in R, bei der ein Codeblock min­des­tens einmal aus­ge­führt wird, gibt es nicht. Die Funk­tio­na­li­tät kann mit Repeat-Schleifen al­ler­dings einfach im­ple­men­tiert werden:

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

Das obige Code­be­spiel gibt die Zahlen von 1 bis 10 aus dem Bild­schirm aus. Der Code, der min­des­tens einmal aus­ge­führt werden soll (und der in einer klas­si­schen Do-While-Loop im „Do-Codeblock“ stünde), wird vor dem if-Statement aus­ge­führt, das die Schleife beendet, wenn die an­ge­ge­be­ne Bedingung zutrifft. 59d941fcf226cf7e6290f28a5cd9d39e