Update article.md

1-js/02-first-steps/11-logical-operators/article.md

@@ -2,7 +2,7 @@
 
 In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), e `!` (NOT).
 
-Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato può essere di qualunque tipo.
+Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani (i risultati stessi possono essere di qualunque tipo).
 
 Vediamoli nei dettagli.
 
@@ -14,7 +14,7 @@ L'operatore "OR" viene rappresentato da due linee verticali:
 result = a || b;
 ```
 
-Nella programmazione classica, l'OR logico è pensato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
+Nella programmazione classica, l'OR logico è utilizzato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`.
 
 In JavaScript questo operatore è un pò più potente. Ma prima vediamo come si comporta con i valori booleani.
 
@@ -27,9 +27,9 @@ alert( true || false );  // true
 alert( false || false ); // false
 ```
 
-Come possiamo vedere, il risultato è sempre `true` tranne nei casi in cui entrambi gli operandi sono `false`.
+Come possiamo vedere, il risultato è sempre `true`, tranne nei casi in cui entrambi gli operandi sono `false`.
 
-Se un operando non è booleano viene convertito per essere valutato.
+Se un operando non è di tipo booleano vi viene momentaneamente convertito per la valutazione.
 
 Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`:
 
@@ -60,7 +60,7 @@ let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // è il fine settimana
+  alert( 'The office is closed.' ); // l'Ufficio è chiuso
 }
 ```
 
@@ -79,12 +79,12 @@ result = value1 || value2 || value3;
 L'operatore OR `||` si comporta come segue:
 
 - Valuta gli operandi da sinistra a destra.
-- Ogni operando viene convertito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando.
-- Se tutti gli altri operandi sono stati valutati (ad esempio tutti erano `false`), ritorna l'ultimo operando.
+- Ogni operando viene convertito a booleano. Se il risultato è `true`, il logical OR si ferma e ritorna il valore originale dell'operando.
+- Se tutti gli operandi sono stati valutati e nessuno è `true`, ritorna l'ultimo operando.
 
 **Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
-In altra parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore trovato.
+In altre parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore.
 
 Ad esempio:
 
@@ -99,7 +99,7 @@ alert( undefined || null || 0 ); // 0 (tutti falsi, ritorna l'ultimo valore)
 
 Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR booleano"boolean-only OR".
 
-1. **Prelevare il primo valore vero da una lista di variabili o espressioni.**
+1. **Trovare il primo valore vero in una lista di variabili o espressioni.**
 
     Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutte opzionali (possono quindi essere *undefined* o avere valori falsi).
 
@@ -119,27 +119,17 @@ Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR
 
 2. **Valutazione a Corto-Circuito.**
 
-    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. OR valuta ed esegue i test da sinistra a destra. La valutazione si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver toccato l’operando successivo. 
+    Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, che viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perchè cerca di concludersi il prima possibile (quando possibile), senza aver raggiunto l’operando successivo. 
 
-    Questo si nota chiaramente quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o una function call.
-
-    Se proviamo ad eseguire l'esempio che segue, `x` non verrà assegnata:
-
-    alert(x); // undefined, perché (x = 1) non viene valutato
-    ```
-
-    Se invece il primo argomento è `false`, allora `||` prosegue e valuta il secondo, in questo caso l'assegnazione funziona:
+    Il logical OR è particolarmente utile quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o la chiamata a una funzione.
+    Nell'esempio che segue solo il secondo messaggio verrà mostrato. 
 
     ```js run no-beautify
     *!*true*/!* || alert("not printed");
     *!*false*/!* || alert("printed");
     ```
-
-    Un'assegnazione è un caso semplice. Potrebbero essere coinvolti altri tipi di side-effect.
-
-    Quello che abbiamo visto, è un "modo breve di fare `if`". Il primo operando viene convertito a booleano e solo se è falso viene eseguito il secondo.
-
-    La maggior parte delle volte è meglio utilizzare un " `if` "regolare", per mantenere il codice leggibile, in alcuni casi però può risultare utile.
+   Nella prima linea l'operatore OR trova subito un valore vero e ferma immediatamente la valutazione, quindi *alert* non viene eseguito.
+   Si può utilizzare questa funzionalità per eseguire un commando nel caso in cui la prima parte della condizione sia falsa. 
 
 ## && (AND)