# Hvordan fungerer while-løkker i R?

Loops er et af de **grundlæggende begreber inden for programmering**. De sikrer, at bestemte kodepassager udføres gentagne gange under en bestemt betingelse. Med while-loops i R gentages et afsnit, indtil den tidligere angivne betingelse bliver falsk.

## Hvad bruges while-løkker i R til?

While-løkker bruges til **gentagne gange at udføre en kodeblok** afhængigt af en betingelse. Så længe denne betingelse er sand, udføres koden i while-løkken.

Loops bruges ofte i R-programmering til at lære om elementer i en R-liste og udføre specifikke handlinger på dem individuelt. For eksempel kan du udskrive en hvilken som helst streng på skærmen fra en liste over R-strenge. Derudover bruges while-loops i R til betinget udførelse af kode. Loops som while-loops er grundlaget for mange kendte **sorteringsalgoritmer**, der organiserer en database efter bestemte kriterier.

## Struktur og syntaks for while-løkker i R

Syntaksen for while-løkker i R ligner syntaksen for while-løkker i de fleste andre programmeringssprog. I løkkeoverskriften, der indledes med nøgleordet *while*, angives betingelsen i parentes. Sidstnævnte skal være sand for, at løkkehullet kan udføres. Dette hull er intet andet end sin egen kodeblok efter løkkeoverskriften, omgivet af krøllede parenteser.

For at illustrere dette har vi lavet et eksempel. Dette R-loop-eksempel viser en while-loop, der udskriver værdier fra 1 til 10:

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

## Bubblesort i R-eksempel

Bubblesort er en klassisk sorteringsalgoritme, der bruges til at **sortere elementer i en R-vektor eller en matrix i R i stigende rækkefølge**. I denne sorteringsalgoritme bruges en while-loop til at udføre sorteringskoden, indtil alle elementer i vektoren er sorteret:

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

I ovenstående kode oprettes en R-funktion kaldet *bubblesort*. Dette sikrer, at en numerisk vektor sorteres i stigende rækkefølge. While-løkken bruges til at udføre udvekslingsprocessen, som er afgørende for Bubblesort, indtil sorteringen er afsluttet.

## Afbryd while-løkken i R

For **at afslutte** en while-loop **før tid** under en bestemt betingelse kan du bruge nøgleordet ‘break’. Dette sikrer, at loopen forlades og ikke genindtrædes. Her er et eksempel på ‘break’-sætningen for at forklare:

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

Ovenstående løkke viser tal fra 10 til 5 på skærmen. Når variablen ‘x’ når værdien 5, udføres R ‘if’-betingelsen, og løkken afsluttes før tid ved at kalde ‘break’.

## Andre sløjfer i R

While-løkken i R er ikke den eneste type løkke i R. Der findes også for-løkken, som ofte betragtes som en slags **tælleløkke**, og repeat-løkken, som bruges til at udføre kode **flere gange, uanset betingelsen**. Repeat-løkker skal afsluttes med nøgleordet ‘break’, ellers er de uendelige løkker.

### For-løkke i R

For-løkker bruges, når antallet af iterationer er kendt på forhånd. Antallet af iterationer angives eksplicit i løkkeoverskriften. En for-løkke, der udskriver tal fra 1 til 5, ser således ud:

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

### Gentag løkke i R

Gentagelsessløjfer i R bruges til at udføre kode flere gange, uanset en betingelse. Hvis du ikke lige er begyndt at programmere, er du sandsynligvis bekendt med do-while-sløjfer fra andre programmeringssprog som Java. Der er ingen eksplicit do-while-sløjfe i R, hvor en kodeblok udføres mindst én gang. Men funktionaliteten kan nemt implementeres med gentagelsessløjfer:

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

Ovenstående kodeeksempel udskriver tal fra 1 til 10. Koden udføres mindst én gang (i en klassisk do-while-løkke i ‘do-kodeblokken’) før ‘if’-sætningen, som afslutter løkken, hvis den angivne betingelse er sand.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/r-mens-loop/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/r-mens-loop/) for AI/LLM consumption.