Os comandos enquanto (while) e fazer-enquanto (do-while)
Tags: javascript, beginners, ptbr, timus
Published: 2019-10-18 17:45:51

## Diferenças entre esses dois comandos de repetição

Os computadores são muito eficientes na realização de tarefas repetitivas. Por causa disso, as linguagens de programação oferecem vários recursos relacionados com o controle dessas repetições.

Um deles é o comando `enquanto` (`while`, em inglês).

Outro é o comando `fazer-enquanto` (`do-while`, em inglês).

Esses dois comandos são parecidos, mas funcionam de forma um pouco diferente. Vamos mostrar aqui aspectos da diferença entre esses dois comandos repetitivos, conforme as regras da linguagem JavaScript.

O comando enquanto tem a seguinte sintaxe:

<div class="highlight"><pre class="highlight javascriptbr"><code><span class="kd">enquanto</span> <span class="p">(</span><span class="nx">condição</span><span class="p">)</span>
    <span class="nx">comando</span></code></pre></div>

Em inglês:

<div class="highlight"><pre class="highlight javascriptbr"><code><span class="kd">while</span> <span class="p">(</span><span class="nx">condição</span><span class="p">)</span>
    <span class="nx">comando</span></code></pre></div>

A execução de um comando `enquanto` é bastante intuitiva, e segue os seguintes passos:

1. A _condição_ é avaliada
2. Caso o resultado seja `não` (falso), o comando que aparece depois da condição **não** é executado, e a execução do programa prossegue com o comando seguinte ao comando `enquanto`.
3. Caso o resultado da avaliação da condição seja `sim` (verdadeiro), o comando é executado e o ciclo recomeça com o passo 1.

O comando `fazer-enquanto` tem a seguinte sintaxe:

<div class="highlight"><pre class="highlight javascriptbr"><code><span class="kd">fazer</span>
    <span class="nx">comando</span>
<span class="kd">enquanto</span> <span class="p">(</span><span class="nx">condição</span><span class="p">)</span></code></pre></div>

Em inglês:

<div class="highlight"><pre class="highlight javascriptbr"><code><span class="kd">do</span>
    <span class="nx">comando</span>
<span class="kd">while</span> <span class="p">(</span><span class="nx">condição</span><span class="p">)</span></code></pre></div>

A execução de um comando `fazer-enquanto` segue os seguintes passos:

1. O _comando_ é executado.
2. A _condição_ é avaliada.
3. Caso o resultado seja `não` (falso), o comando `fazer-enquanto` termina, e a execução do programa prossegue com o comando seguinte ao comando `fazer-enquanto`.
4. Caso o resultado da avaliação da condição seja `sim` (verdadeiro), o ciclo recomeça com o passo 1.

Nestes dois comandos e no outro comando repetitivo – o comando `para` (em inglês, `for`) –, cada execução do comando repetido é chamada de uma **iteração**.

A diferença entre os dois é que, no comando `enquanto`, a avaliação da condição é feita no **início** de cada iteração. Dessa forma, pode acontecer de o _comando_ não ser executado nenhuma vez.

Já no comando `fazer-enquanto`, a _condição_ é avaliada **no final** de cada iteração. Assim, o comando sempre é executado **pelo menos uma vez**.

A rigor, a _condição_ que aparece na sintaxe desses dois comandos corresponde a uma _expressão_. Avaliar a _condição_ significa avaliar a _expressão_.

A _expressão_ pode ser de vários tipos. O resultado da avaliação é convertido para o tipo _lógico_ (_boolean_), conforme indicado na tabela abaixo.

| Tipo da expressão   | Resultado
| -------------       |-------------
| Indefinido            | `não`
| Nulo          | `não`      
| Número       | `não`, se 0 ou Inválido (NaN); caso contrário, `sim`      
| Texto       | `não`, se texto vazio (tamanho 0); caso contrário, `sim`      
| Símbolo       | `sim`      
| Objeto | `sim`
| Lógico | Resultado é a própria _expressão_/_condição_

O resultado dessa conversão para o tipo _lógico_, indicado na tabela acima, determina então o comportamento do comando repetitivo, conforme descrevemos acima.

Esta mesma regra de conversão vale também para a condição que é verificada no comando `se` (`if`).

Por último, uma observação prática: na nossa experiência, o comando `enquanto` é naturalmente bem mais usado do que o `fazer-enquanto`. Também na nossa experiência o comando `para` é naturalmente mais usado do que o `enquanto`. Em outro post vamos detalhar aspectos relacionados com as variações do comando repetitivo `para`.