Merge branch 'master' of https://github.com/javascript-tutorial/it.javascript.info

Author: pasor1

1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md

@@ -1,6 +1,6 @@
 **Certo.**
 
-Qualunque stringa ad eccezione di quella vuota (`"0"` non è vuota) diventa `true` in un contesto logico.
+Qualunque stringa -ad eccezione di quella vuota (`"0"` non lo è)- diventa `true` in contesto booleano.
 
 Possiamo eseguirlo e controllare:
 

1-js/02-first-steps/10-ifelse/2-check-standard/task.md

@@ -4,7 +4,7 @@ importance: 2
 
 # Il nome di JavaScript
 
-Usando il costrutto `if..else`, scrivi il codice che chiede: 'What is the "official" name of JavaScript?'
+Usando il costrutto `if..else`, scrivi un codice che chieda: 'What is the "official" name of JavaScript?'
 
 Se l'utente digita "ECMAScript", ritorna "Right!", altrimenti-- ritorna: "Didn't know? ECMAScript!"
 

1-js/02-first-steps/10-ifelse/3-sign/task.md

@@ -4,12 +4,12 @@ importance: 2
 
 # Mostra il segno
 
-Utilizzando `if..else`, scrivi il codice che preleva un numero tramite `prompt` e lo mostra con un `alert`:
+Utilizzando `if..else`, scrivi un codice che preleva un numero tramite `prompt` e lo mostra con un `alert`:
 
 - `1`, se il valore è maggiore di zero,
 - `-1`, se è minore di zero,
 - `0`, se è uguale a zero.
 
-In questo esercizio assumiamo che l'input sia sempre un numero.
+In questo esercizio supporremo che l'input sia sempre un numero.
 
 [demo src="if_sign"]

1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Riscrivi 'if' con '?'
 
-Riscrivi questo `if` utilizzando l'operatore ternario `'?'`:
+Riscrivi il seguente `if` utilizzando l'operatore ternario `'?'`:
 
 ```js
 let result;

1-js/02-first-steps/10-ifelse/article.md

@@ -2,11 +2,11 @@
 
 Qualche volta abbiamo bisogno di eseguire certe azioni solo nel caso valgano determinate condizioni.
 
-Per questo c'è l'istruzione `if` e anche l'operatore condizionale di valutazione a cui noi ci riferiremo con l'operatore "punto di domanda" `?` per semplicità.
+Per questo c'è l'istruzione `if` e l'operatore condizionale di valutazione a cui ci riferiremo, per semplicità, con "l'operatore punto di domanda" `?`.
 
 ## L'istruzione "if" 
 
-L'istruzione `if(...)` richiede una condizione, la valuta, e se il risultato è `true`, esegue il codice.
+L'istruzione `if(...)` valuta una condizione (racchiusa nelle parentesi); se il risultato è `true`, esegue il codice che segue `if`.
 
 Ad esempio:
 
@@ -20,7 +20,7 @@ if (year == 2015) alert( 'You are right!' );
 
 Nell'esempio sopra, la condizione è un semplice controllo di uguaglianza: `year == 2015`, ma potrebbe essere qualcosa di molto più complesso.
 
-Se dobbiamo eseguire più di un'istruzione, queste vanno raggruppate tramite le parentesi graffe:
+Se dobbiamo eseguire più di un'istruzione, queste vanno raggruppate tramite parentesi graffe:
 
 ```js
 if (year == 2015) {
@@ -29,34 +29,34 @@ if (year == 2015) {
 }
 ```
 
-E' consigliabile raggruppare sempre il codice all'interno delle parentesi graffe `{}` quando si usa un `if`, anche se contiene una sola istruzione. La leggibilità viene migliorata.
+E' consigliabile raggruppare sempre il codice all'interno delle parentesi graffe `{}`, quando si usa un `if`, anche se contiene una sola istruzione. La leggibilità ne guadagna.
 
 ## Conversione booleana
 
-L'istruzione `if (…)` valuta la condizione tra le parentesi e la converte al tipo booleano.
+L'istruzione `if (…)` valuta la condizione tra le parentesi e converte il risultato al tipo booleano.
 
 Ricordiamo le regole di conversione viste nel capitolo <info:type-conversions>:
 
 - Il numero `0`, una stringa vuota `""`, `null`, `undefined` e `NaN` diventano `false`. Per questo vengono chiamati valori "falsi".
 - Gli altri valori diventano `true`, quindi vengono chiamati "veri".
 
-Quindi, il codice nell'esempio qui sotto, non verrà mai eseguito:
+Quindi, il codice nell'esempio sotto, non verrà mai eseguito:
 
 ```js
 if (0) { // 0 è falso
   ...
 }
 ```
 
-...Invece nel prossimo esempio -- verrà eseguito sempre:
+...Nel seguente esempio, invece, verrà sempre eseguito:
 
 ```js
 if (1) { // 1 è vero
   ...
 }
 ```
 
-Possiamo anche passare un valore già valutato in precedenza su un `if`, come qui:
+Possiamo anche passare un valore già valutato in precedenza, come qui:
 
 ```js
 let cond = (year == 2015); // l'uguaglianza diventa vera o falsa
@@ -99,13 +99,13 @@ if (year < 2015) {
 }
 ```
 
-Nel codice sopra JavaScript controlla prima `year < 2015`. Se risulta falso allora va alla successiva condizione `year > 2015`, altrimenti mostra il blocco else con l'`alert`.
+Nel codice sopra JavaScript controlla anzitutto la prima condizione, `year < 2015`. Se risulta falsa va alla successiva condizione `year > 2015` ed esegue il codice dentro le parentesi graffe, altrimenti esegue il codice dentro al blocco `else`.
 
 Ci possono essere molti blocchi `else if`. L'`else` finale è opzionale.
 
 ## Operatore condizionale '?'
 
-Qualche volta abbiamo bisogno di assegnare un valore ad una variabile in base ad una condizione.
+Qualche volta abbiamo bisogno di assegnare un valore ad una variabile in base ad una certa condizione.
 
 Ad esempio:
 
@@ -124,45 +124,45 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-Esiste un'operatore "condizionale" o "punto interrogativo" che ci consente di farlo in maniera più breve e semplice.
+Esiste un operatore "condizionale", o "punto interrogativo", che ci consente di farlo in maniera più breve e semplice.
 
-L'operatore viene rappresentato dal punto interrogativo `?`.  Il termine formale è "ternario", il che significa che richiede tre operatori. E' l'unico operatore in JavaScript di questo tipo.
+L'operatore viene rappresentato dal punto interrogativo `?`.  Il termine formale è "ternario", perché richiede tre operatori. E' l'unico operatore in JavaScript che ne accetta così tanti.
 
 La sintassi è:
 ```js
 let result = condition ? value1 : value2;
 ```
 
-La `condition` viene valutata, se risulta viene ritornato il `value1`, altrimenti viene ritornato il -- `value2`.
+La `condition` viene valutata; se risulta vera, viene ritornato `value1`, altrimenti viene ritornato `value2`.
 
 Ad esempio:
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Tecnicamente, potremmo omettere le parentesi su `age > 18`. L'operatore condizionale ha una precedenza molto bassa. Viene eseguito dopo gli operatori di confronto `>`.
+Tecnicamente, potremmo omettere le parentesi attorno ad `age > 18`. L'operatore condizionale ha una precedenza molto bassa, viene eseguito dopo gli operatori di confronto `>`.
 
-Questo esempio porta allo stesso risultato di quello precedente:
+Il risultato dell'esempio sotto è uguale a quello precedente:
 
 ```js
 // l'operatore di confronto "age > 18" viene eseguito per primo
 // (non c'è bisogno di racchiuderlo tra parentesi)
 let accessAllowed = age > 18 ? true : false;
 ```
 
-Le parentesi rendono però il codice più leggibile, quindi è consigliabile utilizzarle.
+Ma le parentesi rendono il codice più leggibile, quindi è consigliabile utilizzarle.
 
 ````smart
-Nell'esempio sopra sarebbe possibile evitare l'operatore ternario, perchè l'operatore di confronto ritorna già di suo `true/false`:
+Nell'esempio sopra sarebbe possibile omettere anche l'operatore ternario, perchè l'operatore di confronto `>` ritorna già di suo `true/false`:
 
 ```js
-// the same
+// stesso risultato (risulterà in `true` o `false`, a seconda del valore di `age`)
 let accessAllowed = age > 18;
 ```
 ````
 
-## Operatori '?' multipli
+## Multipli operatori '?'
 
 Una sequenza di operatori `?` consente di ritornare un valore che dipende da più condizioni.
 
@@ -178,14 +178,14 @@ let message = (age < 3) ? 'Hi, baby!' :
 alert( message );
 ```
 
-Potrebbe essere difficile inizialmente capirne la logica. Ma dopo averlo guardato da più vicino ci accorgiamo è una semplice sequenza di condizioni.
+Potrebbe essere difficile, inizialmente, capirne la logica. Ma dopo averlo guardato da più vicino ci accorgeremo che è una semplice sequenza di condizioni.
 
 1. Il primo operatore "?" controlla `age < 3`.
-2. Se è vero -- ritorna `'Hi, baby!'`, altrimenti -- segue la colonna `":"` e controlla `age < 18`.
-3. Se questo è vero -- ritorna `'Hello!'`, altrimenti -- segue la colonna `":"` e controlla `age < 100`.
-4. Se questo è vero -- ritorna `'Greetings!'`, altrimenti -- segue la colonna `":"` e ritorna `'What an unusual age!'`.
+2. Se è vero -- ritorna `'Hi, baby!'`, altrimenti -- segue la colonna `":"`, controlla `age < 18`.
+3. Se questo è vero -- ritorna `'Hello!'`, altrimenti -- segue la colonna `":"`, controlla `age < 100`.
+4. Se questo è vero -- ritorna `'Greetings!'`, altrimenti -- segue la colonna `":"`, ritorna `'What an unusual age!'`.
 
-La stessa logica viene usata con `if..else`:
+La stessa logica riscritta utilizzando `if..else`:
 
 ```js
 if (age < 3) {
@@ -212,16 +212,15 @@ let company = prompt('Which company created JavaScript?', '');
 */!*
 ```
 
-In base al risultato della condizione `company == 'Netscape'`, viene eseguita la prima o la seconda parte, e mostra il giusto alert.
+In base alla valutazione della condizione `company == 'Netscape'`, viene eseguita la prima o la seconda parte (e il rispettivo `alert`).
 
-Qui non assegnamo il risultato ad una variabile. L'idea è di eseguire codice differente in base alla condizione.
+Qui non assegniamo il risultato ad una variabile. L'idea è di eseguire un codice differente a seconda della condizione.
 
 **Non è consigliabile utilizzare l'operatore ternario in questo modo.**
 
-La notazione risulta essere molto più breve rispetto all'istruzione `if`, questo viene sfruttato da molti programmatori. Ma risulta meno leggibile.
-
-Lo stesso codice realizzato con un istruzione `if`:
+La notazione risulta essere molto più breve rispetto all'istruzione `if`; questo viene sfruttato da molti programmatori, ma risulta meno leggibile.
 
+Compariamo il codice sopra con una versione che utilizza `if` invece dell'operatore ternario `?`:
 ```js run no-beautify
 let company = prompt('Which company created JavaScript?', '');
 
@@ -234,6 +233,6 @@ if (company == 'Netscape') {
 */!*
 ```
 
-I nostri occhi scannerizzano il codice verticalmente. Quindi i costrutti che si estendono per qualche riga risultano più semplici da capire piuttosto di un'unica istruzione che si estende orrizontalmente.
+I nostri occhi esaminano il codice verticalmente. I costrutti che si estendono per qualche riga risultano più semplici da capire piuttosto di un'unica istruzione che si estende orrizontalmente.
 
-L'idea dell'operatore ternario `?` è di ritornare un valore piuttosto che un altro, in base al valore di una condizione. Va quindi utilizzato solo per questo tipo di situazioni. Invece per eseguire diversi codice è consigliabile utilizzare il costrutto `if`.
+L'idea dell'operatore ternario `?` è di ritornare, in base a una condizione, un valore piuttosto di un altro. Va quindi utilizzato solo in questo tipo di situazioni. Per eseguire diversi codici è consigliabile utilizzare il costrutto `if`.

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`.