Laço While em R: while, repeat e break Explicados

O Laço while

Um laço while em R continua executando seu corpo enquanto uma condição permanece TRUE. Onde um laço for executa uma vez por elemento de algo, o while executa um número desconhecido de vezes - até uma condição mudar:

count <- 1

while (count <= 5) {
  print(count)
  count <- count + 1
}

Três partes fazem todo laço while funcionar, e as três estão visíveis aqui:

1. Preparação antes do laço - count <- 1 dá à condição algo para testar.
2. A condição - count <= 5, construída com os operadores de comparação usuais, verificada antes de cada passada.
3. A atualização dentro do corpo - count <- count + 1 move o laço em direção à parada.

Apague a parte 3 e a condição é TRUE para sempre: o laço nunca termina. Esse é o risco que define o while, e o resto desta página é, em grande parte, sobre administrá-lo.

A Condição É Verificada Antes de Cada Passada

O while testa sua condição primeiro, depois executa o corpo. Duas consequências decorrem disso. Se a condição já for FALSE no início, o corpo executa zero vezes:

stock <- 0

while (stock > 0) {
  print("selling one item")
  stock <- stock - 1
}

print("loop finished without running")

E a verificação acontece entre passadas completas, não no meio do corpo - uma vez que uma passada começa, ela vai até o fim mesmo que a condição vire FALSE no meio do caminho. Se você precisa sair no meio do corpo, é para isso que serve o break (abaixo).

Um Exemplo Prático: Dividindo pela Metade Até Ficar Abaixo de um Limiar

O lar natural do while é o "continue até": você não tem como saber de antemão quantas passadas serão necessárias, então o for não se encaixa. Quantas vezes é possível dividir 1000 pela metade antes de ele cair abaixo de 1?

value <- 1000
steps <- 0

while (value >= 1) {
  value <- value / 2
  steps <- steps + 1
}

print(steps)
cat("final value:", value, "\n")

Dez divisões pela metade, terminando em cerca de 0,977. O padrão - uma variável de estado que o corpo reduz, um contador que ele aumenta - cobre uma parcela enorme dos laços while do mundo real: métodos numéricos que rodam até um erro ser pequeno o suficiente, simulações que rodam até um recurso se esgotar, novas tentativas que continuam até uma chamada ter sucesso.

repeat + break: o do-while do R

R não tem a palavra-chave do-while - nenhum laço que teste sua condição depois do corpo. Mas tem repeat, que itera incondicionalmente para sempre, e break, que sai de qualquer laço imediatamente. Coloque o teste do break no final do corpo de um repeat e você construiu exatamente um do-while - um laço cujo corpo tem garantia de executar pelo menos uma vez:

n <- 1

repeat {
  n <- n * 2
  if (n > 100) break
}

print(n)

O corpo sempre executa antes do primeiro teste, então n é dobrado pelo menos uma vez; o laço sai em 128, a primeira duplicação acima de 100. Use essa forma quando "faça a coisa, depois decida se faz de novo" é a descrição honesta - ler entrada até ela ser válida, sortear amostras até uma se qualificar. Um repeat sem um break alcançável é um laço infinito por construção, então escreva o break primeiro e depois preencha o corpo.

O break funciona de forma idêntica em laços while e for - é a saída geral do "terminamos por aqui", e combina naturalmente com instruções if testando uma condição no meio do corpo.

next Dentro de um Laço while

O next pula o resto da passada atual e volta direto para a verificação da condição. Ele funciona no while exatamente como no for - com uma armadilha específica do while: se o passo de atualização vem depois do next, pulá-lo significa que a variável do laço nunca avança, e você construiu um laço infinito. Coloque a atualização antes do next:

i <- 0

while (i < 10) {
  i <- i + 1          # update FIRST...
  if (i %% 2 != 0) next  # ...then it's safe to skip odd numbers
  print(i)
}

Isto imprime os números pares de 2 a 10. Mova i <- i + 1 para baixo da linha do next e o primeiro valor ímpar pularia a atualização para sempre. Em laços for esse perigo não existe (a variável do laço avança automaticamente), o que é mais um motivo para preferir for quando você está simplesmente percorrendo uma sequência.

Protegendo-se Contra Laços Infinitos

Todo laço infinito é o mesmo bug: nada no corpo altera as variáveis das quais a condição depende - ou as altera na direção errada. Interativamente você pode interromper com Esc ou Ctrl+C, mas em um script o processo simplesmente trava. Dois hábitos previnem isso.

Primeiro, ao escrever a condição, pergunte imediatamente "qual linha do corpo move isto em direção a FALSE?" e garanta que essa linha executa em todo caminho pelo corpo (cuidado com a armadilha do next acima).

Segundo, para laços cuja terminação você não consegue provar facilmente, adicione uma guarda de máximo de iterações para que um bug de lógica produza um resultado diagnosticável em vez de uma sessão congelada. Aqui ela protege um laço estilo Collatz - divida pela metade os números pares e transforme x ímpar em 3 * x + 1, repetidamente, até chegar a 1:

x <- 10
steps <- 0

while (x != 1 && steps < 10000) {
  if (x %% 2 == 0) x <- x / 2 else x <- 3 * x + 1
  steps <- steps + 1
}

cat("reached", x, "after", steps, "steps\n")

Partindo de 10, o laço chega a 1 em 6 passos. Se algum valor inicial nunca chegasse a 1, a cláusula steps < 10000 ainda encerraria o laço, e o estado impresso lhe diria que algo deu errado - uma resposta errada que você consegue ver vence um programa que nunca responde. O && com curto-circuito é o operador certo aqui: os dois lados são valores únicos, e a guarda se lê como uma frase.

while vs for: Escolhendo

A regra prática é sobre o que você sabe de antemão:

• Você sabe sobre o que está iterando (elementos de um vetor, números de 1 a n): use um laço for - a variável do laço se administra sozinha.
• Você só sabe a condição de parada (até convergir, até ficar abaixo do limiar, até ser válido): use while.
• O corpo precisa executar pelo menos uma vez antes de qualquer teste fazer sentido: use repeat com um break que encerre.

Se você se pegar mantendo um contador manual em um laço while só para percorrer um vetor, isso é um laço for disfarçado - troque.

O Que Você Leva Daqui

• while (condição) { ... } verifica primeiro, depois executa - uma condição falsa no início significa zero passadas.
• O corpo precisa mover a condição em direção a FALSE; o trio preparação / condição / atualização é toda a disciplina.
• R não tem palavra-chave do-while: repeat { corpo; if (pronto) break } é o idioma, garantindo pelo menos uma passada.
• break sai de qualquer laço; com next em um while, atualize a variável do laço antes do pulo ou ela nunca avança.
• Uma guarda de máximo de iterações (&& steps < 10000) transforma um possível travamento em uma resposta errada visível e depurável.

A seguir: vetores - a estrutura de dados que todo laço desta página esteve percorrendo, e o motivo de muitos laços em R poderem desaparecer por completo.