Merge pull request #451 from gabifs/translate/while-for

Translate/while for

Author: gabifs

1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md

@@ -1,4 +1,4 @@
-The answer: `1`.
+A resposta: `1`.
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+Cada iteração do laço diminui `i` em `1`. A verificação `while(i)` para o laço quando `i = 0`.
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+Portanto, os passos do laço formam a seguinte sequência ("laço desenrolado"):
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // mostra 3, diminui i para 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // mostra 2, diminui i para 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // mostra 1, diminui i para 0
 
-// done, while(i) check stops the loop
+// fim, a verificação while(i) para o laço
 ```

1-js/02-first-steps/13-while-for/1-loop-last-value/task.md

@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Last loop value
+# Último valor do laço
 
-What is the last value alerted by this code? Why?
+Qual é o último valor exibido por este código? Por quê?
 
 ```js
 let i = 3;

1-js/02-first-steps/13-while-for/2-which-value-while/solution.md

@@ -1,30 +1,30 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+A tarefa demonstra como as formas pós-fixa/prefixa podem levar a resultados diferentes quando usadas em comparações.
 
-1. **From 1 to 4**
+1. **De 1 a 4**
 
     ```js run
     let i = 0;
     while (++i < 5) alert( i );
     ```
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+    O primeiro valor é `i = 1`, porque `++i` primeiro incrementa `i` e depois retorna o novo valor. Então a primeira comparação é `1 < 5` e o `alert` mostra `1`.
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+    Depois seguem `2, 3, 4…` -- os valores aparecem um após o outro. A comparação sempre usa o valor incrementado, porque `++` está antes da variável.
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+    Finalmente, `i = 4` é incrementado para `5`, a comparação `while(5 < 5)` falha, e o laço para. Então `5` não é mostrado.
+2. **De 1 a 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+    O primeiro valor é novamente `i = 1`. A forma pós-fixa de `i++` incrementa `i` e depois retorna o valor *antigo*, então a comparação `i++ < 5` usará `i = 0` (ao contrário de `++i < 5`).
 
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+    Mas a chamada `alert` é separada. É outra instrução que executa após o incremento e a comparação. Então ela obtém o `i = 1` atual.
 
-    Then follow `2, 3, 4…`
+    Depois seguem `2, 3, 4…`
 
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+    Vamos parar em `i = 4`. A forma prefixa `++i` incrementaria e usaria `5` na comparação. Mas aqui temos a forma pós-fixa `i++`. Então ela incrementa `i` para `5`, mas retorna o valor antigo. Portanto, a comparação é na verdade `while(4 < 5)` -- verdadeiro, e o controle segue para `alert`.
 
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+    O valor `i = 5` é o último, porque no próximo passo `while(5 < 5)` é falso.

1-js/02-first-steps/13-while-for/2-which-value-while/task.md

@@ -2,19 +2,19 @@ importance: 4
 
 ---
 
-# Which values does the while loop show?
+# Quais valores o laço while mostra?
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+Para cada iteração do laço, escreva qual valor ele exibe e depois compare com a solução.
 
-Both loops `alert` the same values, or not?
+Ambos os laços exibem os mesmos valores via `alert`, ou não?
 
-1. The prefix form `++i`:
+1. A forma prefixa `++i`:
 
     ```js
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. The postfix form `i++`
+2. A forma pós-fixa `i++`
 
     ```js
     let i = 0;

1-js/02-first-steps/13-while-for/3-which-value-for/solution.md

@@ -1,17 +1,17 @@
-**The answer: from `0` to `4` in both cases.**
+**A resposta: de `0` a `4` em ambos os casos.**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
 
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+Isso pode ser facilmente deduzido do algoritmo do `for`:
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. Executa uma vez `i = 0` antes de tudo (begin).
+2. Verifica a condição `i < 5`
+3. Se `true` -- executa o corpo do laço `alert(i)`, e depois `i++`
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+O incremento `i++` é separado da verificação da condição (2). É apenas outra instrução.
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+O valor retornado pelo incremento não é usado aqui, então não há diferença entre `i++` e `++i`.

1-js/02-first-steps/13-while-for/3-which-value-for/task.md

@@ -2,18 +2,18 @@ importance: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# Quais valores o laço "for" mostra?
 
-For each loop write down which values it is going to show. Then compare with the answer.
+Para cada laço, escreva quais valores ele vai mostrar. Depois compare com a resposta.
 
-Both loops `alert` same values or not?
+Ambos os laços exibem os mesmos valores via `alert`, ou não?
 
-1. The postfix form:
+1. A forma pós-fixa:
 
     ```js
     for (let i = 0; i < 5; i++) alert( i );
     ```
-2. The prefix form:
+2. A forma prefixa:
 
     ```js
     for (let i = 0; i < 5; ++i) alert( i );

1-js/02-first-steps/13-while-for/4-for-even/solution.md

@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+Usamos o operador "módulo" `%` para obter o resto e verificar a paridade aqui.

1-js/02-first-steps/13-while-for/4-for-even/task.md

@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output even numbers in the loop
+# Exiba números pares no laço
 
-Use the `for` loop to output even numbers from `2` to `10`.
+Use o laço `for` para exibir números pares de `2` a `10`.
 
 [demo]

1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md

@@ -3,7 +3,7 @@
 ```js run
 let i = 0;
 while (i < 3) {
-  alert( `number ${i}!` );
+  alert( `número ${i}!` );
   i++;
 }
 ```

1-js/02-first-steps/13-while-for/5-replace-for-while/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Replace "for" with "while"
+# Substitua "for" por "while"
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+Reescreva o código alterando o laço `for` para `while` sem alterar seu comportamento (a saída deve permanecer a mesma).
 
 ```js run
 for (let i = 0; i < 3; i++) {