Lussen zijn een van de ba­sis­con­cep­ten van pro­gram­me­ren. Ze zorgen ervoor dat bepaalde passages van code her­haal­de­lijk worden uit­ge­voerd onder een bepaalde voor­waar­de. Met while-lussen in R wordt een sectie herhaald totdat de eerder ge­spe­ci­fi­ceer­de voor­waar­de onwaar wordt.

Waar worden while-lussen in R voor gebruikt?

While-lussen worden gebruikt om een blok code her­haal­de­lijk uit te voeren, af­han­ke­lijk van een voor­waar­de. Zolang deze voor­waar­de waar is, wordt de code in de while-lus uit­ge­voerd.

Lussen worden vaak gebruikt in R-pro­gram­me­ring om meer te weten te komen over elementen van een R-lijst en om spe­ci­fie­ke acties op elk element af­zon­der­lijk uit te voeren. U kunt bij­voor­beeld elke string uit een lijst met R-strings op het scherm weergeven. Daarnaast worden while-lussen in R gebruikt voor de voor­waar­de­lij­ke uit­voe­ring van code. Lussen zoals de while-lus vormen de basis van veel bekende sor­teer­al­go­rit­men die een database volgens bepaalde criteria ordenen.

Structuur en syntaxis van while-lussen in R

De syntaxis van while-lussen in R is ver­ge­lijk­baar met die van while-lussen in de meeste andere pro­gram­meer­ta­len. In de lusheader, die wordt ge­ïn­tro­du­ceerd met het sleu­tel­woord while, wordt de voor­waar­de tussen haakjes ge­spe­ci­fi­ceerd. Deze voor­waar­de moet waar zijn om de lus te kunnen uitvoeren. Deze lus is niets meer dan een eigen blok code na de lusheader, omsloten door accolades.

Om dit te il­lu­stre­ren, hebben we een voorbeeld gemaakt. Dit R-lus­voor­beeld toont een while-lus die waarden van 1 tot 10 uitvoert:

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

Bub­ble­s­ort in R-voorbeeld

Bub­ble­s­ort is een klassiek sor­teer­al­go­rit­me dat wordt gebruikt om elementen van een R-vector of een array in R in oplopende volgorde te sorteren. In dit sor­teer­al­go­rit­me wordt een while-lus gebruikt om de sor­teer­co­de uit te voeren totdat alle elementen van de vector zijn ge­sor­teerd:

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)
}
R

In de bo­ven­staan­de code wordt een R-functie met de naam bub­ble­s­ort aan­ge­maakt. Deze zorgt ervoor dat een numerieke vector in oplopende volgorde wordt ge­sor­teerd. De while-lus wordt gebruikt om het uit­wis­se­lings­pro­ces uit te voeren, wat es­sen­ti­eel is voor Bub­ble­s­ort, totdat het sorteren is voltooid.

On­der­bre­king tijdens lus in R

Om een while-lus onder bepaalde om­stan­dig­he­den voor­tij­dig te verlaten, kunt u het sleu­tel­woord ‘break’ gebruiken. Dit zorgt ervoor dat de lus wordt verlaten en niet opnieuw wordt uit­ge­voerd. Hier volgt een voorbeeld van de ‘break’-in­struc­tie ter ver­dui­de­lij­king:

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

De bo­ven­staan­de lus geeft de getallen van 10 tot 5 weer op het scherm. Wanneer de variabele ‘x’ de waarde 5 bereikt, wordt de R ‘if’-voor­waar­de uit­ge­voerd en wordt de lus voor­tij­dig beëindigd door ‘break’ aan te roepen.

Andere lussen in R

De while-lus in R is niet de enige soort lus in R. Er is ook de for-lus, die vaak wordt gezien als een soort tel-lus, en de repeat-lus, die wordt gebruikt om code meerdere keren uit te voeren , ongeacht een voor­waar­de. Repeat-lussen moeten worden af­ge­slo­ten met het sleu­tel­woord ‘break’, anders zijn het oneindige lussen.

For-lus in R

For-lussen worden gebruikt wanneer het aantal iteraties vooraf bekend is. Het aantal iteraties wordt expliciet ge­spe­ci­fi­ceerd in de lusheader. Een for-lus die getallen van 1 tot 5 uitvoert, ziet er als volgt uit:

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

Herhaal lus in R

Her­ha­lings­lus­sen in R worden gebruikt om code meerdere keren uit te voeren, ongeacht een voor­waar­de. Als u niet net begint met pro­gram­me­ren, bent u waar­schijn­lijk bekend met do-while-lussen uit andere pro­gram­meer­ta­len zoals Java. Er is geen ex­pli­cie­te do-while-lus in R waarbij een blok code minstens één keer wordt uit­ge­voerd. Maar de func­ti­o­na­li­teit kan eenvoudig worden ge­ïm­ple­men­teerd met her­ha­lings­lus­sen:

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

Het bo­ven­staan­de co­de­voor­beeld geeft getallen van 1 tot 10 weer. De code wordt minstens één keer uit­ge­voerd (in een klassieke do-while-lus in het ‘do-codeblok’) vóór de ‘if’-in­struc­tie, die de lus beëindigt als de opgegeven voor­waar­de waar is.

Ga naar hoofdmenu