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

Author: pasor1

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -2,18 +2,17 @@
 
 [recent browser="new"]
 
-Qui, in questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.
-
-Il nullish coalescing operator è scritto come due punti di domanda `??`.
+Il *nullish coalescing operator* è rappresentato da due punti di domanda `??`.
 
 Il risultato di `a ?? b` è:
 - se `a` è definito, allora `a`,
 - se `a` non è definito, allora `b`.
 
+(In questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.)
 
-In altre parole, `??` ritorna il primo argomento se questo non è `null/undefined`. Altrimenti, ritorna il secondo.
+In altre parole, tra due operatori `??` ritorna il primo se questo non è `null/undefined`; altrimenti, ritorna il secondo.
 
-Il nullish coalescing operator non è qualcosa di completamente nuovo. È solo un modo più elegante (una migliore sintassi) per recuperare il primo valore "definito" dei due.
+Il nullish coalescing operator non è qualcosa di completamente nuovo. È solo un modo più elegante per recuperare il primo valore "definito" tra due operatori.
 
 Possiamo riscrivere `result = a ?? b` usando gli operatori che già conosciamo, nel seguente modo:
 
@@ -41,18 +40,18 @@ alert(user ?? "Anonymous"); // John
 
 Possiamo anche usare una sequenza di `??` per selezionare, da una lista, il primo valore che non sia `null/undefined`.
 
-Per esempio, supponiamo di avere dei dati relativi ad un utente nelle variabili `firstName`, `lastName` o `nickName`. Tutte queste potrebbero essere non definite, se l'utente dovesse decidere di non inserirne i valori.
+Per esempio, supponiamo di avere i dati di un utente nelle variabili `firstName`, `lastName` o `nickName`. Tutte queste potrebbero essere non definite, se l'utente dovesse decidere di non inserirne i valori.
 
-Vorremmo visualizzare il nome dell'utente usando una di queste variabili, oppure mostrare "Anonymous" se tutte queste sono indefinite.
+Vorremmo visualizzare il nome dell'utente usando una di queste variabili, oppure mostrare "Anonymous" se nessuna di esse è definita.
 
-Usiamo l'operatore `??`per questo:
+Usiamo l'operatore `??`:
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// shows the first defined value:
+// mostra il primo valore valido:
 *!*
 alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
 */!*
@@ -69,25 +68,25 @@ let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// shows the first truthy value:
+// mostra il primo valore vero:
 *!*
 alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
-L'operatore OR `||` esiste sin dagli inizi di JavaScript, quindi gli sviluppatori lo hanno usato a tale scopo per molto tempo.
+L'operatore OR `||` esiste sin dagli inizi di JavaScript e gli sviluppatori lo hanno usato a tale scopo per molto tempo.
 
-D'altro canto, il nullish coalescing operator `??` fu aggiunto in JavaScript recentemente, poichè le persone non erano del tutto felici dell'operatore `||`.
+Il nullish coalescing operator `??`, invece, è stato aggiunto  recentemente. La ragione è che alcuni sviluppatori non erano del tutto contenti dell'operatore `||`.
 
 L'importante differenza tra essi è la seguente:
 - `||` ritorna il primo valore *truthy*.
 - `??` ritorna il primo valore *definito*.
 
-In altre parole, `||` non distingue tra `false`, `0`, una stringa vuota `""` e `null/undefined`. Sono tutti, allo stesso modo -- valori "falsy". Se uno tra questi è il primo argomento di `||`, allora otterremo il secondo argomento come risultato.
+In altre parole, `||` non distingue tra `false`, `0`, una stringa vuota `""` e `null/undefined`. In contesto booleano sono tutti valori `false`. Se uno di questi è il primo argomento di `||`, verrà ritornato il secondo argomento.
 
-In pratica, però, potremmo voler usare il valore di default solamente quando la variabile è `null/undefined`. È in questo caso che il valore è davvero sconosciuto/non settato.
+In pratica, però, potremmo voler usare il valore di default solamente quando la variabile è `null/undefined`. Ovvero quando è veramente non definita: una stringa vuota `''` o `0`, ad esempio, potrebbero tornarci utili.
 
-Per esempio, consideriamo questo:
+Per esempio, consideriamo il seguente codice:
 
 ```js run
 let height = 0;
@@ -96,24 +95,24 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- `height || 100` controlla se `height` possiede un valore "falsy", ed effettivamente così è,
-    - quindi il risultato è il secondo argomento, `100`.
-- `height ?? 100` controlla se `height` è `null/undefined`, ma così non è,
-    - quindi il risultato è `height` "così com'è", ovvero `0`.
+- `height || 100` controlla se `height` ha un valore falso: così è.
+    - il risultato è dunque il secondo argomento, `100`.
+- `height ?? 100` controlla se `height` è `null/undefined`: non lo è.
+    - quindi il risultato è `height`, ovvero `0`.
 
-Se un'altezza pari a zero è un valore accettabile, allora questo non dovrebbe essere rimpiazzato con il valore di default, quindi `??` fa la cosa giusta.
+Se un'altezza pari a zero è un valore accettabile, questo non dovrebbe essere rimpiazzato con il valore di default (il secondo operatore, nel'esempio sopra `100`); in questo caso il *nullish coalescing operator* `??` è la scelta giusta.
 
 ## Precedenza
 
-La precedenza dell'operatore `??` è piuttosto bassa: `5` nella [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). Quindi `??` è valutato prima di `=` e `?`, ma dopo la maggior parte degli altri operatori, come `+`, `*`.
+La precedenza dell'operatore `??` è piuttosto bassa: `5` nella [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). Quindi `??` è valutato prima di `=` e `?`, ma dopo la maggior parte degli altri operatori, come `+` o `*`.
 
 Quindi, se volessimo scegliere un valore tramite l'operatore `??` in un'espressione contenente altri operatori, dovremmo considerare l'utilizzo delle parentesi:
 
 ```js run
 let height = null;
 let width = null;
 
-// important: use parentheses
+// importante: utilizzare le parentesi
 let area = (height ?? 100) * (width ?? 50);
 
 alert(area); // 5000
@@ -122,24 +121,24 @@ alert(area); // 5000
 Altrimenti, se omettessimo le parentesi, siccome `*` ha una precedenza maggiore rispetto a `??`, sarebbe eseguito prima, portando a risultati scorretti.
 
 ```js
-// without parentheses
+// senza parentesi
 let area = height ?? 100 * width ?? 50;
 
-// ...works the same as this (probably not what we want):
+// ...funziona allo stesso modo del seguente codice (probabilmente non ciò che vogliamo)
 let area = height ?? (100 * width) ?? 50;
 ```
 
 ### Usare ?? con && o ||
 
 Per motivi di sicurezza, JavaScript proibisce l'utilizzo di `??` insieme agli operatori `&&` e `||`, a meno che la precedenza non sia esplicitamente specificata tramite l'utilizzo delle parentesi.
 
-Il codice sottostante causa un errore di sintassi:
+Il codice sotto causa un errore di sintassi:
 
 ```js run
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-La limitazione è sicuramente discutibile, ma fu aggiunta alle specifiche del linguaggio con lo scopo di evitare errori di programmazione nel momento in cui le persone hanno iniziato ad utilizzare `??` al posto di `||`.
+La limitazione è sicuramente discutibile, ma fu aggiunta alle specifiche del linguaggio -quando le persone hanno iniziato ad utilizzare `??` al posto di `||`- con lo scopo di evitare errori di programmazione.
 
 Per aggirare il problema si possono utilizzare delle parentesi esplicite:
 
@@ -151,16 +150,16 @@ let x = (1 && 2) ?? 3; // Works
 alert(x); // 2
 ```
 
-## Sommario
+## Riepilogo
 
 - Il nullish coalescing operator `??` fornisce una scorciatoia per la scelta del primo valore "definito" da una lista di valori.
 
     È usato per assegnare valori di default alle variabili:
 
     ```js
-    // set height=100, if height is null or undefined
+    //  imposta height = 100 se 'height' è *null* o *undefined*
     height = height ?? 100;
     ```
 
-- L'operatore `??` ha una precedenza molto bassa, solo un po' più alta di `?` e `=`, quindi considerare l'aggiunta di parentesi quando lo si utilizza all'interno di un'espressione.
+- L'operatore `??` ha una precedenza molto bassa, solo un po' più alta di `?` e `=`, quindi va considerata l'aggiunta di parentesi quando lo si utilizza all'interno di un'espressione.
 - È proibito usarlo con `||` o `&&` senza l'utilizzo di parentesi esplicite.

1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/solution.md

@@ -1,6 +1,6 @@
-Per ottener un match preciso con il costrutto `switch`, `if` deve utilizzare l'uguaglianza stretta `'==='`.
+Per ottenere una corrispondenza precisa con il costrutto `switch`, `if` deve utilizzare l'uguaglianza stretta `'==='`.
 
-Per le stringhe fornite, un semplice `'=='` può bastare.
+Per le stringhe fornite, tuttavia, un semplice `'=='` può bastare.
 
 ```js no-beautify
 if(browser == 'Edge') {

1-js/02-first-steps/14-switch/2-rewrite-if-switch/solution.md

@@ -1,4 +1,4 @@
-I primi due controlli vengono trasmormati in due `case`. Il terzo controllo viene diviso in due casi:
+I primi due controlli vengono trasformati in due `case` separati. Il terzo controllo viene diviso in due `case` raggruppati:
 
 ```js run
 let a = +prompt('a?', '');
@@ -23,4 +23,4 @@ switch (a) {
 
 Da notare: il `break` alla fine non è richiesto. Lo abbiamo messo per rendere il codice pronto ad aggiornamenti futuri.
 
-In futuro, potremmo voler aggiungere un ulteriore `case`, ad esempio `case 4`. E se ci dimentichiamo di aggiungere il break prima di scrivere il nuovo case, al termine del `case 3` ci sarà un errore. Quindi aggiungere il break è una sorta di auto-certezza.
+In futuro, potremmo voler aggiungere un ulteriore `case`, ad esempio `case 4`. E se ci dimentichiamo di aggiungere il `break` prima di scrivere il nuovo `case`, al termine del `case 3` ci sarà un errore. Quindi aggiungere il `break` è una sorta di prevenzione.

1-js/02-first-steps/14-switch/2-rewrite-if-switch/task.md

@@ -2,7 +2,7 @@ importance: 4
 
 ---
 
-# Riscrivi "if" con "switch"
+# Riscrivi "if" utilizzando "switch"
 
 Riscrivi il codice sotto utilizzando un singolo `switch`:
 

1-js/02-first-steps/14-switch/article.md

@@ -1,14 +1,14 @@
 # L'istruzione "switch"
 
-L'istruzione `switch` può essere utile per rimpiazzare `if` multipli.
+L'istruzione `switch` può essere utile per rimpiazzare multipli `if`.
 
-E' infatti un metodo molto più descrittivo per confrontare un valore che può assumere più varianti.
+E' infatti un metodo molto più descrittivo per lavorare con un elemento che può avere svariati valori.
 
 ## La sintassi
 
-Un istruzione `switch` possiede uno o più `case` ed opzionalmente un blocco default.
+Un istruzione `switch` possiede uno o più `case` ed opzionalmente un blocco *default*.
 
-Appare cosi:
+Un esempio:
 
 ```js no-beautify
 switch(x) {
@@ -26,9 +26,9 @@ switch(x) {
 }
 ```
 
-- Il valore di `x` viene controllato utilizzando l'uguaglianza stretta con il valore fornito dal primo blocco `case` (che è, `value1`) poi dal secondo (`value2`) e avanti cosi.
+- Il valore di `x` viene controllato utilizzando l'uguaglianza stretta con i valori dei blocchi `case` (`value1` e `value2` nell'esempio sopra).
 - Se l'uguaglianza viene trovata, `switch` inizia ad eseguire il codice partendo dal corrispondente blocco `case`, fino al `break` più vicino (oppure fino alla fine dello `switch`).
-- Se non viene trovata nessuna uguaglianza allora viene eseguito il codice del blocco `default` (se questo è presente).
+- Se non viene trovata nessuna uguaglianza allora viene eseguito il codice del blocco `default` (se presente).
 
 ## Un esempio
 
@@ -54,11 +54,11 @@ switch (a) {
 }
 ```
 
-Qui lo `switch` inizia confrontando `a` con il primo `case`, la sua variante è `3`. Quindi il match fallisce.
+Qui lo `switch` inizia confrontando `a` con il primo `case`, il cui valore è `3`. Non vi è corrispondenza.
 
-Poi valuta `4`. Questo è un match riuscito, quindi l'esecuzione inizia da `case 4` fino al `break` più vicino.
+Poi valuta `4`. C'è una corrispondenza, quindi l'esecuzione inizia da `case 4` fino al `break` più vicino.
 
-**Se non c'è nessun `break` l'esecuzione procede al prossimo `case` senza alcun controllo.**
+**Se non c'è nessun `break` l'esecuzione procede al prossimo `case`.**
 
 Un esempio senza `break`:
 
@@ -79,7 +79,7 @@ switch (a) {
 }
 ```
 
-Nell'esempio sopra abbiamo visto l'esecuzione sequenziale dei tre `alert`:
+Nell'esempio sopra, non essendoci un `break`, abbiamo l'esecuzione sequenziale dei tre `alert`:
 
 ```js
 alert( 'Exactly!' );
@@ -107,12 +107,13 @@ switch (+a) {
     alert("this doesn't run");
 }
 ```
-Qui `+a` viene convertito in `1`, che viene confrontato con `b + 1` nei `case`, ed il codice corrispondente viene eseguito.
-````
+```
+Qui `+a` viene convertito in `1`, che nei `case` viene confrontato con `b + 1`, ed il codice corrispondente viene eseguito. 
+``` 
 
 ## Raggruppare i "case"
 
-Diverse varianti di `case` che condividono lo stesso codice possono essere raggruppate.
+Possiamo raggruppare diverse varianti di `case` e far loro eseguire lo stesso codice.
 
 Ad esempio, se vogliamo eseguire lo stesso codice per `case 3` e `case 5`:
 
@@ -139,11 +140,11 @@ switch (a) {
 
 Ora sia `3` che `5` mostreranno lo stesso messaggio.
 
-L'abilità di "raggruppare" più case è un effetto collaterale di come `switch/case` funziona senza `break`. Qui l'esecuzione del case `case 3` inizia dalla linea `(*)` e prosegue fino a `case 5`, perchè non c'è alcun `break`.
+L'abilità di "raggruppare" più `case` è un effetto collaterale di come `switch/case` funziona senza `break`. Qui l'esecuzione del `case 3` inizia dalla linea `(*)` e prosegue fino a `case 5`, perché non c'è alcun `break`.
 
 ## Il tipo conta
 
-Mettiamo in risalto che il confronto di uguaglianza è sempre stretto. I valori devono essere dello stesso tipo perchè si possa avere un match.
+Mettiamo in risalto che il confronto di uguaglianza è sempre stretto. I valori devono essere dello stesso tipo perché si possa avere una corrispondenza.
 
 Ad esempio, consideriamo il codice:
 
@@ -167,6 +168,6 @@ switch (arg) {
 }
 ```
 
-1. Per `0`, `1`, viene eseguito il primo `alert`.
+1. Per `0` e `1`, viene eseguito il primo `alert`.
 2. Per `2` viene eseguito il secondo `alert`.
-3. Ma per `3`, il risultato del `prompt` è una stringa `"3"`, che non è strettamente uguale `===` al numero `3`. Quindi qui abbiamo del codice morto in  `case 3`! Verrà quindi eseguita la variante `default`.
+3. Per `3`, il risultato del `prompt` è una stringa, `"3"`, che non è strettamente uguale `===` al numero `3`. Quindi abbiamo del codice 'morto' nel `case 3`! Verrà quindi eseguito il codice dentro `default`.