Merge pull request #195 from Dorin-David/Articolo/nullish-operator

Articolo/nullish operator

Author: longo-andrea

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.