Passo 1 de 8
O que se repete no programa
Diferencie a repetição criada no código das chamadas automáticas de loop() e preveja quando uma sequência finita recomeça.
Trilha de aprendizado · Nível 9 · Tutorial 7
Repita ações com while e for, calculando a quantidade de iterações e verificando se a repetição termina sem ultrapassar os limites do contador.
O que se repete no programa
Diferencie a repetição criada no código das chamadas automáticas de `loop()` e preveja quando uma sequência finita recomeça. 2 min
while: testar, executar e atualizar
Construa e rastreie um while simples, observando o teste antes do corpo, a atualização do contador e o teste final falso. 3 min
for: organizar uma repetição contada
Organize uma contagem planejada com for e compare sua ordem de execução com um while equivalente. 3 min
Quantas vezes o corpo será executado?
Calcule iterações enumerando os valores que entram no corpo e confira o valor do teste final. 3 min
O laço consegue chegar ao fim?
Analise se a atualização do contador permite que a condição de continuidade se torne falsa. 2 min
A faixa do contador também importa
Analise os limites de um contador sem sinal e escolha uma faixa que permita ao laço alcançar sua condição de término. 3 min
Aplicar o laço a uma sequência de piscadas
Aplique um for seguro para gerar uma sequência observável e finita de piscadas no LED integrado do Uno R3. 3 min
Revisão final: prever, completar e conferir
Revisão integrada de equivalência entre for e while, contagem de piscadas e término seguro do contador. 2 min
Passo 1 de 8
Diferencie a repetição criada no código das chamadas automáticas de loop() e preveja quando uma sequência finita recomeça.
Um laço é uma estrutura escrita no programa para repetir um bloco de instruções. Cada vez que o corpo desse laço é executado, ocorre uma iteração.
Mas um sketch Arduino também tem uma repetição própria: depois de setup() terminar, o ambiente chama loop() novamente e novamente. Essa chamada automática não é um laço que você escreveu dentro do código; ela faz parte do funcionamento do ambiente Arduino.
setup() ocorre uma vez após a inicialização; loop() é chamado repetidamente pelo ambiente.
Imagine que exista uma repetição escrita dentro de uma função. Ela executa seu corpo algumas vezes e então termina. Ao terminar, o programa segue para a próxima instrução da mesma função.
Portanto, terminar um laço não encerra o sketch. Ele apenas encerra aquela repetição interna.
Se uma sequência finita estiver em setup(), ela será iniciada uma vez por inicialização ou reset. Se estiver em loop(), ela poderá ser iniciada de novo quando uma chamada de loop() terminar e o ambiente fizer a próxima chamada.
Exemplo
Considere estes dois comportamentos, sem se preocupar ainda com a sintaxe usada para repetir:
Em setup()
setup().setup() termina.loop().Em loop()
loop().loop() termina.loop() outra vez: a sequência pode recomeçar.Associe cada situação ao comportamento esperado.
Faça as associações.
Toque em um item e depois no par correspondente.
Passo 2 de 8
Construa e rastreie um while simples, observando o teste antes do corpo, a atualização do contador e o teste final falso.
Um while repete um bloco enquanto sua condição for verdadeira. A condição fica entre parênteses, e o corpo do laço fica entre chaves.
Para controlar a repetição, organize o código em quatro partes:
O teste ocorre antes do corpo. Portanto, se a condição já for falsa, o corpo não executa nenhuma vez.
O corpo só é alcançado quando o teste da condição resulta em verdadeiro.
Exemplo para estudar: o contador começa em 0 e o corpo deve executar enquanto ele for menor que 3.
int contador = 0;
while (contador < 3) {
// Uma ação é executada aqui.
contador++;
}
// O programa continua aqui.contador++ aumenta o valor armazenado em contador em uma unidade. Neste uso, ele é uma instrução de atualização: acontece depois do corpo e antes do próximo teste.
Quando contador chega a 3, a comparação contador < 3 é falsa. O corpo não é executado com o valor 3; o programa segue para a primeira instrução após as chaves.
Rastreie cada teste, não apenas as vezes em que o corpo executa.
| Valor no teste | contador < 3 | Corpo executa? | Valor após atualização |
|---|---|---|---|
| 0 | verdadeiro | sim | 1 |
| 1 | verdadeiro | sim | 2 |
| 2 | verdadeiro | sim | 3 |
| 3 | falso | não | — |
Considere o início da execução do exemplo anterior. Coloque as etapas na ordem em que acontecem na primeira passagem pelo laço.
Escreva pelo menos 80 caracteres (0/80).
Agora organize a mesma primeira passagem em etapas.
Ordene as etapas da primeira passagem pelo while.
Complete o while para executar o corpo com os valores 0, 1 e 2 e, depois, sair do laço.
int contador = 0;
while (contador 3) {
// Uma ação é executada aqui.
contador;
}
// O programa continua aqui.
Passo 3 de 8
Organize uma contagem planejada com for e compare sua ordem de execução com um while equivalente.
Use for quando você já planeja uma contagem. O cabeçalho reúne três partes, separadas por ponto e vírgula:
A atualização não ocorre antes da primeira passagem pelo corpo.
A condição vem antes do corpo; a atualização vem depois do corpo e antes do próximo teste.
Este laço usa no corpo os valores 0, 1 e 2 para contador.
for (int contador = 0; contador < 3; contador++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(200);
digitalWrite(LED_BUILTIN, LOW);
delay(200);
}No exemplo, a ordem real é:
int contador = 0 executa uma vez;contador < 3 é verdadeiro: executa o corpo com contador igual a 0;contador++ muda o valor para 1;contador++ produz 3;contador < 3 é falso, então o laço termina.Portanto, a atualização também acontece após a última execução do corpo. O valor 3 não chega ao corpo, mas é avaliado no teste final.
Compare os valores e a posição da atualização no exemplo.
| Momento | contador | contador < 3 | Ação |
|---|---|---|---|
| Inicialização | 0 | — | Prepara o laço |
| 1º teste | 0 | Verdadeiro | Corpo; depois incrementa |
| 2º teste | 1 | Verdadeiro | Corpo; depois incrementa |
| 3º teste | 2 | Verdadeiro | Corpo; depois incrementa |
| Teste final | 3 | Falso | Sai do laço |
Um for simples pode ser escrito como um while com a mesma ordem de operações. A inicialização fica antes do while, a condição permanece no teste e a atualização fica no fim do corpo.
Os dois trechos usam contador com os valores 0, 1 e 2 dentro do corpo.
// Forma com for
for (int contador = 0; contador < 3; contador++) {
// corpo
}
// Forma equivalente com while
int contador = 0;
while (contador < 3) {
// corpo
contador++;
}Dica
for é uma escolha usual quando a contagem está planejada no cabeçalho. while costuma deixar mais evidente uma repetição cuja continuidade depende de uma condição. Isso é uma escolha de clareza: ambos podem expressar a mesma repetição simples.
Complete o cabeçalho para executar o corpo com contador igual a 1, 2 e 3, nessa ordem.
for (; ; ) {
digitalWrite(LED_BUILTIN, HIGH);
delay(100);
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}
Passo 4 de 8
Calcule iterações enumerando os valores que entram no corpo e confira o valor do teste final.
A quantidade de execuções não depende apenas do número que aparece no limite. Confira sempre três elementos: valor inicial, condição e passo de atualização.
O método mais seguro é listar os valores que realmente chegam ao corpo do laço. Cada valor listado corresponde a uma iteração.
Em for (int i = 0; i < 4; i++), os valores no corpo são 0, 1, 2 e 3: portanto, são 4 execuções. O valor 4 não entra no corpo, porque falha no teste i < 4.
Os valores destacados entram no corpo; o valor seguinte aparece apenas no teste final que encerra o laço.
Compare condições muito parecidas: < exclui o limite; <= inclui o limite.
| Cabeçalho | Valores no corpo | Execuções |
|---|---|---|
| for (int i = 0; i < 4; i++) | 0, 1, 2, 3 | 4 |
| for (int i = 0; i <= 4; i++) | 0, 1, 2, 3, 4 | 5 |
| for (int i = 1; i < 1; i++) | nenhum | 0 |
Leia cada cabeçalho e acompanhe os valores de n que chegam ao corpo. A atualização ocorre depois do corpo, inclusive após a última execução.
// Corpo executa com n = 2, 4, 6, 8
for (int n = 2; n < 10; n += 2) {
// uma iteração
}
// Corpo executa com n = 5, 3, 1
for (int n = 5; n >= 1; n -= 2) {
// uma iteração
}
// A condição já é falsa: corpo não executa
for (int n = 7; n < 7; n++) {
// zero iterações
}Dica
No primeiro exemplo, depois de usar 8, o programa atualiza n para 10. Esse 10 é testado, mas não executa o corpo porque 10 < 10 é falso.
No exemplo decrescente, o último valor usado é 1. Após o corpo, n passa para -1; o teste -1 >= 1 é falso. Diferencie o último valor usado no corpo do valor que provoca o teste final falso.
Quantas vezes o corpo deste laço será executado?
for (int n = 7; n < 7; n++) {
digitalWrite(LED_BUILTIN, HIGH);
}Complete o cabeçalho para que o corpo execute exatamente três vezes, com n valendo 5, 3 e 1, nessa ordem.
for (int n = ; n 1; n ) {
digitalWrite(LED_BUILTIN, HIGH);
}
Passo 5 de 8
Analise se a atualização do contador permite que a condição de continuidade se torne falsa.
Em cada volta, pergunte: qual valor muda? E essa mudança leva a condição para false?
No exemplo while (contador < 3), um contador que começa em 0 precisa aumentar: 0, 1, 2 executam o corpo; depois, ao chegar a 3, o teste fica falso e o programa segue adiante.
Alterar uma variável não é suficiente. A atualização precisa ocorrer na direção compatível com a condição.
A condição contador < 3 deixa de ser verdadeira quando a atualização leva o contador até 3.
Atenção
Não grave nem execute na placa um laço que você ainda não confirmou que termina. Se ele não chega ao fim, o fluxo fica preso no corpo do laço e as instruções seguintes não são alcançadas.
Exemplo defeituoso: contador nunca muda.
int contador = 0;
while (contador < 3) {
digitalWrite(LED_BUILTIN, HIGH);
}
digitalWrite(LED_BUILTIN, LOW);Como contador permanece em 0, o teste contador < 3 continua verdadeiro. O comando que apaga o LED está depois do while, portanto não é executado enquanto o laço permanece ativo.
A correção exige atualizar o contador dentro do corpo, de modo que ele possa alcançar um valor que torne a condição falsa.
Exemplo defeituoso: a atualização existe, mas segue no sentido errado.
int contador = 0;
while (contador < 3) {
contador--;
}O contador segue 0, -1, -2... Todos esses valores continuam menores que 3. Para sair de uma condição com < 3, este contador deveria avançar até 3 ou mais, não diminuir.
Considere o código abaixo, apenas por análise:
int contador = 3;
while (contador > 0) {
contador++;
}Esse laço consegue chegar ao fim?
Escreva pelo menos 20 caracteres (0/20).
Complete a atualização que permite ao laço terminar.
int contador = 0;
while (contador < 3) {
digitalWrite(LED_BUILTIN, HIGH);
contador;
}
digitalWrite(LED_BUILTIN, LOW);
Passo 6 de 8
Analise os limites de um contador sem sinal e escolha uma faixa que permita ao laço alcançar sua condição de término.
uint8_t representa apenas valores de 0 a 255. Ao incrementar um contador que já vale 255, o valor armazenado volta para 0. No sentido contrário, ao decrementar 0, ele volta para 255.
Isso importa para o término: não basta olhar os valores usados no corpo. Confira também a atualização que ocorre depois da última iteração pretendida. Ela precisa produzir um valor representável que torne a condição falsa.
Para terminar, a atualização final precisa alcançar um valor que faça a condição falhar.
Compare a condição com todos os valores que o tipo consegue armazenar.
| Início e atualização | Condição | Transição na fronteira | Resultado |
|---|---|---|---|
| 0; contador++ | contador <= 255 | 255 → 0 | Nunca fica falsa |
| 255; contador-- | contador >= 0 | 0 → 255 | Nunca fica falsa |
Atenção
Considere este laço, mas não o grave nem o execute na placa. O contador avança na direção esperada, porém não consegue sair da faixa de uint8_t.
Com números matemáticos, seria natural prever que depois de 255 viria 256 e que contador <= 255 ficaria falso. No tipo usado de verdade, a atualização armazena 0. Como 0 também satisfaz a condição, o corpo recomeça.
Enquanto o laço permanece ativo, as instruções seguintes da função não são alcançadas.
Exemplo para analisar; não execute este código na placa.
uint8_t contador = 0;
while (contador <= 255) {
// corpo do laço
contador++;
}
// Este ponto nunca é alcançado.Atenção
Não aplique a mesma conclusão a tipos com sinal. Exceder a faixa de um inteiro com sinal não é uma estratégia válida de controle: o comportamento não é definido pela linguagem. Em vez de depender de um retorno, escolha tipo, limite e atualização para que todos os valores necessários sejam representáveis.
Se o corpo deve usar todos os valores de 0 a 255, inclusive 255, o contador também precisa guardar o próximo valor: 256. Um tipo mais largo permite a atualização final e o teste falso, sem perder nenhuma iteração planejada.
A sequência é: corpo com 254, atualização para 255; corpo com 255, atualização para 256; teste 256 <= 255, que é falso. Portanto, o corpo executa 256 vezes.
Este for preserva os valores de 0 a 255 no corpo e termina após a atualização para 256.
for (uint16_t contador = 0; contador <= 255; contador++) {
// corpo executado com contador de 0 a 255
}
// Aqui, contador já não existe: era local ao for.Complete o cabeçalho para executar o corpo com todos os valores de 0 a 255 e terminar em seguida.
for ( contador = 0; contador 255; contador++) {
// executa para 0, 1, ..., 255
}
Passo 7 de 8
Aplique um for seguro para gerar uma sequência observável e finita de piscadas no LED integrado do Uno R3.
Cada iteração do for será uma piscada completa: acender o LED, esperar, apagar e esperar novamente. Antes do laço, uma pausa de 1 segundo separa a sequência dos flashes que podem ocorrer durante a gravação ou a reinicialização.
No exemplo, o contador assume os valores 0, 1 e 2 no corpo do laço. Portanto, haverá 3 piscadas. Ao final de cada iteração, o LED já foi comandado para LOW; assim, ele termina apagado.
Os três pulsos representam as três execuções do corpo do laço; entre eles, o LED volta ao estado apagado.
No seu computador, abra a IDE Arduino, crie um sketch e copie o código abaixo. Use somente o Arduino Uno R3 ligado por USB: não conecte fontes, fios ou cargas externas.
Compile e grave. Após a gravação, espere a pausa inicial e conte as piscadas do LED integrado. Durante cada delay, e durante toda a sequência, o fluxo fica bloqueado: nenhuma instrução seguinte pode avançar até a espera terminar.
Sketch completo para gravar localmente no Uno R3.
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
delay(1000); // pausa para separar a observação da gravação
for (int piscada = 0; piscada < 3; piscada++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(300);
digitalWrite(LED_BUILTIN, LOW);
delay(300);
}
}
void loop() {
// Não há novas ações após a sequência de setup.
}Após cerca de 1 segundo, o LED integrado produz exatamente três piscadas e permanece apagado. A sequência só ocorre novamente após reset ou nova inicialização.
O resultado é visual no LED integrado, não aparece como texto na IDE. A sequência só acontece novamente após reset ou nova inicialização.
Atenção
Não conte possíveis flashes durante a gravação nem imediatamente após ela. A sequência que interessa começa depois da pausa inicial de 1 segundo. Como o for está em setup(), ela acontece uma vez a cada inicialização ou reset — não se reinicia pelas chamadas repetidas de loop().
Complete o cabeçalho para que o corpo seja executado com piscada valendo 0, 1 e 2. Isso deve produzir três piscadas completas.
Preencha as três partes que definem a contagem.
for (int piscada = ; piscada ; piscada++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(300);
digitalWrite(LED_BUILTIN, LOW);
delay(300);
}Com o Uno ainda conectado somente por USB, pressione o botão de reset da placa uma vez. A pausa inicial e as três piscadas devem ocorrer novamente. Relate a previsão e o que você observou; esta resposta serve para sua própria conferência da prática.
Escreva pelo menos 80 caracteres (0/80).
Passo 8 de 8
Revisão integrada de equivalência entre for e while, contagem de piscadas e término seguro do contador.
Nesta revisão, transforme uma sequência contada de piscadas em um while equivalente. Antes de executar qualquer laço, confira: início, condição, atualização, faixa do contador e efeito de cada iteração.
Cada valor de vez que chega ao corpo produz uma piscada completa: acende, espera, apaga e espera. Os valores usados são 0, 1 e 2; depois, vez passa a 3 e o teste falha.
Três valores entram no corpo; o valor 3 é usado apenas no teste final.
O for inicializa vez uma vez, testa antes de cada piscada e a incrementa depois do corpo. O while equivalente precisa preservar exatamente essa ordem.
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
for (uint8_t vez = 0; vez < 3; vez++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(300);
digitalWrite(LED_BUILTIN, LOW);
delay(300);
}
}
void loop() {
}Complete o while equivalente ao for mostrado. Ele deve produzir três piscadas e terminar com o LED apagado.
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
vez = ;
while (vez 3) {
digitalWrite(LED_BUILTIN, HIGH);
delay(300);
digitalWrite(LED_BUILTIN, LOW);
delay(300);
vez;
}
}
void loop() {
}Qual análise está correta para o while completado?
Resumo
for e um while são equivalentes quando preservam a mesma inicialização, teste, corpo e atualização.Parabéns! Você concluiu: Repetições com while e for
Muito bem! Use o checklist de início, condição, atualização, faixa e efeito sempre que criar ou revisar um laço.
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
Leve o conhecimento no seu bolso.
Baixe o aplicativo Cursa.
São centenas de Cursos gratuitos a disposição, com Certificado de conclusão gratuito que é salvo em sua galeria de imagens do celular.
Baixe o app para ter acesso ao Certificado de conclusão de Curso Gratuitamente.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks
