Merge pull request #134 from matmont/feature/nullishCoalescingOperator

Update article.md

Author: longo-andrea

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

@@ -2,50 +2,50 @@
 
 [recent browser="new"]
 
-Here, in this article, we'll say that an expression is "defined" when it's neither `null` nor `undefined`.
+Qui, in questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.
 
-The nullish coalescing operator is written as two question marks `??`.
+Il nullish coalescing operator è scritto come due punti di domanda `??`.
 
-The result of `a ?? b` is:
-- if `a` is defined, then `a`,
-- if `a` isn't defined, then `b`.
+Il risultato di `a ?? b` è:
+- se `a` è definito, allora `a`,
+- se `a` non è definito, allora `b`.
 
 
-In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
+In altre parole, `??` ritorna il primo argomento se questo non è `null/undefined`. Altrimenti, ritorna il secondo.
 
-The nullish coalescing operator isn't anything completely new. It's just a nice syntax to get the first "defined" value of the two.
+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.
 
-We can rewrite `result = a ?? b` using the operators that we already know, like this:
+Possiamo riscrivere `result = a ?? b` usando gli operatori che già conosciamo, nel seguente modo:
 
 ```js
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
-The common use case for `??` is to provide a default value for a potentially undefined variable.
+Un caso d'uso comune per l'operatore `??` è quello di fornire un valore di default per una variabile potenzialmente "non definita".
 
-For example, here we show `Anonymous` if `user` isn't defined:
+Per esempio, qui mostriamo `Anonymous` se `user` non è definito:
 
 ```js run
 let user;
 
 alert(user ?? "Anonymous"); // Anonymous
 ```
 
-Of course, if `user` had any value except `null/undefined`, then we would see it instead:
+Ovviamente, se `user` ha un qualsiasi valore eccetto `null/undefined`, allora vedremo quel valore:
 
 ```js run
 let user = "John";
 
 alert(user ?? "Anonymous"); // John
 ```
 
-We can also use a sequence of `??` to select the first value from a list that isn't `null/undefined`.
+Possiamo anche usare una sequenza di `??` per selezionare, da una lista, il primo valore che non sia `null/undefined`.
 
-Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be undefined, if the user decided not to enter a value.
+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.
 
-We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are undefined.
+Vorremmo visualizzare il nome dell'utente usando una di queste variabili, oppure mostrare "Anonymous" se tutte queste sono indefinite.
 
-Let's use the `??` operator for that:
+Usiamo l'operatore `??`per questo:
 
 ```js run
 let firstName = null;
@@ -58,11 +58,11 @@ alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
 */!*
 ```
 
-## Comparison with ||
+## Confronti con ||
 
-The OR `||` operator can be used in the same way as `??`, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
+L'operatore OR `||` può essere usato nello stesso modo dell'operatore `??`, come descritto nel [capitolo precedente](info:logical-operators#or-finds-the-first-truthy-value).
 
-For example, in the code above we could replace `??` with `||` and still get the same result:
+Per esempio, nel codice precedente potremmo rimpiazzare `??` con `||` e ottenere comunque il medesimo risultato:
 
 ```js run
 let firstName = null;
@@ -75,19 +75,19 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
-The OR `||` operator exists since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+L'operatore OR `||` esiste sin dagli inizi di JavaScript, quindi gli sviluppatori lo hanno usato a tale scopo per molto tempo.
 
-On the other hand, the nullish coalescing operator `??` was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
+D'altro canto, il nullish coalescing operator `??` fu aggiunto in JavaScript recentemente, poichè le persone non erano del tutto felici dell'operatore `||`.
 
-The important difference between them is that:
-- `||` returns the first *truthy* value.
-- `??` returns the first *defined* value.
+L'importante differenza tra essi è la seguente:
+- `||` ritorna il primo valore *truthy*.
+- `??` ritorna il primo valore *definito*.
 
-In other words, `||` doesn't distinguish between `false`, `0`, an empty string `""` and `null/undefined`. They are all the same -- falsy values. If any of these is the first argument of `||`, then we'll get the second argument as the result.
+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 practice though, we may want to use default value only when the variable is `null/undefined`. That is, when the value is really unknown/not set.
+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.
 
-For example, consider this:
+Per esempio, consideriamo questo:
 
 ```js run
 let height = 0;
@@ -96,18 +96,18 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- The `height || 100` checks `height` for being a falsy value, and it really is.
-    - so the result is the second argument, `100`.
-- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
-    - so the result is `height` "as is", that is `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`.
 
-If the zero height is a valid value, that shouldn't be replaced with the default, then `??` does just the right thing.
+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.
 
-## Precedence
+## Precedenza
 
-The precedence of the `??` operator is rather low: `5` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). So `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
+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 `+`, `*`.
 
-So if we'd like to choose a value with `??` in an expression with other operators, consider adding parentheses:
+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;
@@ -119,7 +119,7 @@ let area = (height ?? 100) * (width ?? 50);
 alert(area); // 5000
 ```
 
-Otherwise, if we omit parentheses, then as `*` has the higher precedence than `??`, it would execute first, leading to incorrect results.
+Altrimenti, se omettessimo le parentesi, siccome `*` ha una precedenza maggiore rispetto a `??`, sarebbe eseguito prima, portando a risultati scorretti.
 
 ```js
 // without parentheses
@@ -129,19 +129,19 @@ let area = height ?? 100 * width ?? 50;
 let area = height ?? (100 * width) ?? 50;
 ```
 
-### Using ?? with && or ||
+### Usare ?? con && o ||
 
-Due to safety reasons, JavaScript forbids using `??` together with `&&` and `||` operators, unless the precedence is explicitly specified with parentheses.
+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.
 
-The code below triggers a syntax error:
+Il codice sottostante causa un errore di sintassi:
 
 ```js run
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-The limitation is surely debatable, but it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch to `??` from `||`.
+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 `||`.
 
-Use explicit parentheses to work around it:
+Per aggirare il problema si possono utilizzare delle parentesi esplicite:
 
 ```js run
 *!*
@@ -151,16 +151,16 @@ let x = (1 && 2) ?? 3; // Works
 alert(x); // 2
 ```
 
-## Summary
+## Sommario
 
-- The nullish coalescing operator `??` provides a short way to choose the first "defined" value from a list.
+- Il nullish coalescing operator `??` fornisce una scorciatoia per la scelta del primo valore "definito" da una lista di valori.
 
-    It's used to assign default values to variables:
+    È usato per assegnare valori di default alle variabili:
 
     ```js
     // set height=100, if height is null or undefined
     height = height ?? 100;
     ```
 
-- The operator `??` has a very low precedence, only a bit higher than `?` and `=`, so consider adding parentheses when using it in an expression.
-- It's forbidden to use it with `||` or `&&` without explicit parentheses.
+- 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.
+- È proibito usarlo con `||` o `&&` senza l'utilizzo di parentesi esplicite.