Merge pull request #191 from Dorin-David/Article/13-while-for

13 while for

Author: longo-andrea

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

@@ -1,4 +1,4 @@
-La risposta: `1`.
+La risposta è: `1`.
 
 ```js run
 let i = 3;
@@ -15,11 +15,11 @@ Quindi, gli step del ciclo sono ("loop unrolled"):
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); //mostra 3, decrementa i a 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // mostra 2, decrementa i a 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // mostra 1, decrementa i a 0
 
-// done, while(i) check stops the loop
+// finito, `i` è ora 0, che convertito a booleano è falso
 ```

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

@@ -4,7 +4,7 @@ importance: 3
 
 # Valore all'ultimo ciclo
 
-Qualè l'ultimo valore stampato da alert in questo codice? Perchè?
+Qual è l'ultimo valore mostrato da *alert* in questo codice? Perché?
 
 ```js
 let i = 3;

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

@@ -9,9 +9,9 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è `i = 1`, perchè `++i` incrementa prima `i` e poi ritorna il nuovo valore. Quindi il primo confronto è `1 < 5` e `alert` mostra `1`.
 
-    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confroto utilizza sempre il valose incrementato, perchè `++` è posto prima della variabile.
+    Poi seguono `2, 3, 4…` -- i valori vengono mostrati uno dopo l'altro. Il confronto utilizza sempre il valore incrementato, perchè `++` è posto prima della variabile.
 
-    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` fallisce, e il ciclo termina. Quindi `5` non viene mostrato.
+    Ultima iterazione, `i = 4` viene incrementato a `5`, il confronto `while(5 < 5)` risulta `false`, e il ciclo termina. `5` non viene mostrato.
 
 2. **Da 1 a 5**
 
@@ -22,10 +22,10 @@ L'esercizio dimostrava come le forme prefissa/postfissa possono portare a risult
 
     Il primo valore è ancora `i = 1`. La forma postfissa `i++` incrementa `i` e ritorna il *vecchio* valore, quindi il confronto `i++ < 5` utilizza `i = 0` (a differenza di `++i < 5`).
 
-    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento e il confronto. Quindi avra il valore `i = 1`.
+    La chiamata ad `alert` è separata. E' un istruzione che viene eseguita dopo l'incremento di `i` e il controllo della condizione. Quindi `i = 1`.
 
     Seguono `2, 3, 4…`
 
-    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel confronto. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è `while(4 < 5)` -- vero, il controllo passa alla chiamata `alert`.
+    Fermiamoci a `i = 4`. La forma prefissa `++i` incrementerebbe ed utilizzerebbe `5` nel controllo della condizione `i < 5`. Qui però stiamo usando la forma postfissa `i++`. Quindi incrementa `i`a `5`, ma ritorna il vecchio valore. Il confronto è dunque `while(4 < 5)` -- vero; il controllo passa alla chiamata `alert`.
 
-    Il valore `i = 5` è l'ultimo, perchè nello step successivo avremmo `while(5 < 5)` che è falso.
+    Il valore `i = 5` è l'ultimo, perchè nell'iterazione successiva avremmo `while(5 < 5)` e la condizione sarebbe falsa.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori mostra il ciclo while?
+# Quali valori mostrerà il ciclo while?
 
-Per ogni iterazione del ciclo, scrivi quali valori vengono mostrati e poi confrontali alla soluzione.
+Per ogni iterazione del ciclo, scrivi quali valori verranno mostrati e poi confrontali con la soluzione.
 
-Entrambi i cicli mostrano gli stessi valori in `alert`, o no?
+Entrambi i cicli mostreranno gli stessi valori in `alert`, o no?
 
 1. La forma prefissa `++i`:
 

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

@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-Questo può eserre facilmete dedotto dall'algoritmo  `for`:
+Questo può essere facilmente dedotto dall'algoritmo  `for`:
 
-1. Esegue un asola volta `i = 0` come prima cosa (begin)
+1. Esegue come prima cosa `i = 0` (una sola volta)
 2. Verifica la condizione `i < 5`
-3. Se è `true` -- esegue il corpo del ciclo `alert(i)`, successivamente `i++`
+3. Se è `true` -- esegue il corpo del ciclo, dove si trova `alert(i)`, poi incrementa `i` di 1
 
-L'incremento `i++` è separato dal controllo della condizione(2). E' un istruzione differente.
+L'incremento `i++` è separato dal controllo della condizione(2). E' un'istruzione differente.
 
 Il valore ritornato non viene utilizzato, quindi non c'è differenza tra `i++` e `++i`.

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

@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Quali valori verrano mostrati dal ciclo "for"?
+# Quali valori verranno mostrati dal ciclo "for"?
 
 Per ogni ciclo scrivete quali valori verranno mostrati. Poi confrontateli con la soluzione.
 
-Entrambi gli `alert` mostrano gli stessi valori?
+I due `alert` mostreranno gli stessi valori?
 
 1. Forma postfissa:
 

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

@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-Utilizziamo l'operatore modulo `%` per ottenre il resto e controllare la parità.
+Utilizziamo l'operatore modulo `%` per controllare che un numero sia pari.

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

@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Stampare i numeri pari con un ciclo
+# Mostra i numeri pari con un ciclo 'for'
 
-Utilizzate il ciclo `for` per stampare i numeri pari da `2` a `10`.
+Utilizzate il ciclo `for` per mostrare i numeri pari da `2` a `10`.
 
 [demo]

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

@@ -4,7 +4,7 @@ importance: 5
 
 # Sostituisci "for" con "while"
 
-Riscrivi il codice cambiando il ciclo `for` con `while` senza modificare il comportamento (l'output deve rimanere lo stesso).
+Riscrivi il ciclo `for` utilizzando la sintassi `while`, ma senza alterarne la funzionalità (l'output deve rimanere lo stesso).
 
 ```js run
 for (let i = 0; i < 3; i++) {

1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md

@@ -7,9 +7,9 @@ do {
 } while (num <= 100 && num);
 ```
 
-Il ciclo `do..while` si ripete fino a chè entrambe le condizioni non risultano vere:
+Il ciclo `do..while` si ripete fintanto che entrambe le condizioni non risultano vere:
 
-1. Il controllo `num <= 100` -- controlla se il valore non risulta ancora maggiore di `100`.
-2. Il controllo `&& num` è falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
+1. Il controllo `num <= 100` -- controlla se il valore non risulti ancora maggiore di `100`.
+2. Il controllo `&& num` diventa falso quando `num` è `null` o una stringa. Quindi il ciclo `while` termina.
 
-P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza il secondo controllo il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambi i controlli sono necessari.
+P.S. Se `num` è `null` allora la condizione `num <= 100` è `true`, quindi senza la seconda condizione il ciclo non terminerebbe nel caso in cui l'utente prema CANCEL. Entrambe le condizioni sono necessarie.