# Como funcionam os loops while em R?

Os loops são um dos **conceitos básicos da programação**. Eles garantem que certas passagens de código sejam executadas repetidamente sob uma determinada condição. Com os loops while em R, uma secção é repetida até que a condição especificada anteriormente se torne falsa.

## Para que servem os loops while em R?

Os loops while são utilizados para **executar repetidamente um bloco de código** em função de uma condição. Enquanto essa condição for verdadeira, o código do loop while é executado.

Os loops são frequentemente utilizados na programação R para conhecer os elementos de uma lista R e para realizar ações específicas sobre eles individualmente. Por exemplo, pode mostrar no ecrã qualquer cadeia de uma lista de cadeias R. Além disso, os loops while em R são utilizados para a execução condicional de código. Os loops como o loop while são a base de muitos **algoritmos de ordenação** conhecidos que organizam uma base de dados de acordo com determinados critérios.

## Estrutura e sintaxe dos loops while em R

A sintaxe dos loops while em R é semelhante à dos loops while na maioria das outras linguagens de programação. No cabeçalho do loop, que é introduzido com a palavra-chave *while*, a condição é especificada entre parênteses. Esta deve ser verdadeira para que o núcleo do loop seja executado. Este núcleo não é mais do que o seu próprio bloco de código após o cabeçalho do loop, encerrado entre chaves.

Para ilustrar isso, criámos um exemplo. Este exemplo de loop em R mostra um loop while que retorna valores de 1 a 10:

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

## Exemplo: Bubble Sort em R

Bubble Sort é um algoritmo de ordenação clássico usado para **ordenar os elementos de um vetor em R ou de uma matriz em R em ordem crescente**. Neste algoritmo de ordenação, usa-se um loop while para executar o código de ordenação até que todos os elementos do vetor estejam ordenados:

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

No código anterior, é criada uma função R chamada *bubblesort*. Isso garante que um vetor numérico seja ordenado em ordem crescente. O loop while é usado para realizar o processo de troca, que é essencial para o Bubble Sort, até que a ordenação seja concluída.

## Interrupção do loop while em R

Para **sair prematuramente** de um loop while sob uma determinada condição, pode utilizar a palavra-chave «break». Isso garante que sai do loop e não volta a entrar nele. Aqui está um exemplo da instrução «break» para explicar:

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

O loop anterior mostra os números de 10 a 5 no ecrã. Quando a variável «x» atinge o valor 5, a condição R «if» é executada e o loop termina prematuramente chamando «break».

## Outros loops em R

O while loop em R não é o único tipo de loop em R. Existe também o for loop, que é frequentemente considerado um tipo de **loop de contagem**, e o repeat loop, que é usado para executar código **várias vezes, independentemente de uma condição**. Os loops de repetição devem ser finalizados com a palavra-chave “break”, caso contrário, são loops infinitos.

### Loop for em R

Os loops for são utilizados quando o número de iterações é conhecido antecipadamente. O número de iterações é especificado explicitamente no cabeçalho do loop. Um loop for que produz números de 1 a 5 tem a seguinte aparência:

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

### Repetir loop em R

Os loops de repetição em R são usados para executar código várias vezes, independentemente de uma condição. Se já tem experiência em programação, provavelmente está familiarizado com os loops do-while de outras linguagens de programação, como Java. Em R, não existe um loop do-while explícito em que um bloco de código seja executado pelo menos uma vez. No entanto, a funcionalidade pode ser facilmente implementada com loops de repetição:

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

O exemplo de código acima produz números de 1 a 10. O código é executado pelo menos uma vez (num clássico loop do-while no «do codeblock») antes da instrução «if», que termina o loop se a condição especificada for verdadeira.


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/r-while-loop/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/r-while-loop/) for AI/LLM consumption.