Merge pull request #151 from pasor1/article/09-comparison

Corretto ed aggiornato articolo ed esercizi 02/09-comparison

Author: pasor1

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -12,9 +12,9 @@ null === +"\n0\n" → false
 
 I motivi:
 
-1. Ovviamente vale true.
-2. Confronto lessico-grafico, quindi false.
-3. Nuovamente, confronto lessico-grafico, il primo carattere di `"2"` è maggiore del primo carattere `"1"`.
+1. Ovviamente è true.
+2. Confronto lessicografico, quindi false.
+3. Nuovamente, confronto lessicografico, il primo carattere di `"2"` è maggiore del primo carattere `"1"`.
 4. I valori `null` e `undefined` sono uguali solo tra di loro.
 5. L'uguaglianza stretta è stretta. I tipi differenti dei due operandi portano ad un risultato false.
 6. Vedi `(4)`, `null` equivale solamente a `undefined`..

1-js/02-first-steps/09-comparison/1-comparison-questions/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Confronti
 
-Qual'è il risultato di queste espressioni?
+Quale sarà il risultato di queste espressioni?
 
 ```js no-beautify
 5 > 4

1-js/02-first-steps/09-comparison/article.md

@@ -1,15 +1,17 @@
 # Confronti
 
-Molti operatori di confronto li conosciamo già dalla matematica:
+Molti operatori di confronto già li conosciamo dalla matematica:
 
-- Maggiore/minore di: <code>a &gt; b</code>, <code>a &lt; b</code>.
-- Maggiore/minore o uguale di: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- L'uguaglianza viene scritta come `a == b` (da notare che si utilizza due volte il simbolo `=`. Il simbolo unico`a = b` significa assegnazione).
-- Non uguale. In matematica la notazione è <code>&ne;</code>, in JavaScript viene scritto come un'assegnazione ma con un punto esclamativo davanti: <code>a != b</code>.
+- Maggiore/minore: <code>a &gt; b</code>, <code>a &lt; b</code>.
+- Maggiore/minore o uguale: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Uguaglianza: `a == b` (da notare che il doppio simbolo `=` indica un test di uguaglianza, mentre il simbolo unico `a = b` rappresenta un' assegnazione).
+- Disuguaglianza. In matematica la notazione è <code>&ne;</code>, mentre in JavaScript viene scritto come <code>a != b</code>.
+
+In questo articolo impareremo più approfonditamente i vari tipi di confronto, come vengono gestiti in JavaScript, incluse alcune importanti peculiarità
 
 ## Il risultato è booleano
 
-Come tutti gli altri operatori, quelli di confronto ritornano un valore. In questo caso il valore di ritorno è di tipo booleano.
+Tutti gli operatori di confronto restituiscono un valore booleano.
 
 - `true` -- significa "si", "corretto" o "vero".
 - `false` -- significa "no", "sbagliato" o "falso".
@@ -31,9 +33,9 @@ alert( result ); // true
 
 ## Confronto di stringhe
 
-Per vedere quale stringa è più lunga di un'altra, viene utilizzato l'ordine "dizionario" o meglio "lessico-grafico".
+Per vedere quale stringa è maggiore di un'altra, viene utilizzato il cosiddetto ordine "dizionario" o "lessicografico".
 
-In altre parole, le stringhe vengono confrontate lettera a lettera.
+In altre parole, le stringhe vengono confrontate lettera per lettera.
 
 Ad esempio:
 
@@ -45,24 +47,24 @@ alert( 'Bee' > 'Be' ); // true
 
 L'algoritmo per confrontare due stringhe è semplice:
 
-1. Confronta i primi caratteri di entrambe le stringhe.
-2. Se il primo è maggiore(o minore), allora la prima stringa è maggiore(o minore) della seconda. Abbiamo quindi finito.
-3. Altrimenti se i primi caratteri sono uguali, vengono comparati i secondi, nella stessa maniera.
+1. Confronta il primo carattere di entrambe le stringhe.
+2. Se il primo carattere della prima stringa è maggiore(o minore) di quello della seconda stringa, allora la prima stringa è maggiore(o minore) della seconda. Abbiamo quindi finito.
+3. Altrimenti, se il primo carattere di entrambe le stringhe è identico, viene comparato il secondo nella stessa maniera.
 4. Viene ripetuto questo procedimento fino alla fine di una delle due stringhe.
-5. Se entrambe le stringhe finiscono nello stesso istante, allora sono uguali. Altrimenti la stringa più lunga è maggiore.
+5. Se entrambe le stringhe hanno la medesima lunghezza, allora sono uguali. Altrimenti la stringa più lunga è quella maggiore.
 
-Nell'esempio sopra, il confronto `'Z' > 'A'` ritorna il risultato al primo passo dell'algoritmo.
+Nell'esempio sopra, il confronto `'Z' > 'A'` porta ad un risultato al primo passo dell'algoritmo.
 
-Mentre il secondo confronto tra `"Glow"` e `"Glee"` richiede più passi poichè le stringhe vengono confrontate carattere per carattere:
+Mentre il secondo confronto tra `"Glow"` e `"Glee"` richiede più passi poiché le stringhe vengono confrontate carattere per carattere:
 
 1. `G` è uguale a `G`.
 2. `l` è uguale a `l`.
 3. `o` è maggiore di `e`. Qui si ferma. La prima stringa è maggiore.
 
-```smart header="Non un vero dizionario, ma un ordine Unicode"
-L'algoritmo di confronto esaminato sopra è molto simile a quello utilizzato nei dizionari cartacei o nelle agende telefoniche. Ma non è proprio uguale.
+```smart header="Non un vero e proprio dizionario, ma un ordine Unicode"
+L'algoritmo di confronto esaminato sopra è molto simile a quello utilizzato nei dizionari cartacei o nelle agende telefoniche, ma non è esattamente lo stesso.
 
-Ad esempio, le lettere maiuscole contano. Una lettera maiuscola `"A"` non è uguale alla stessa minuscola `"a"`. Qual'è più grande? In realtà, quella minuscola. Come mai? Perchè le lettere minuscole hanno un indice di encoding maggiore nella tabella(Unicode). Ritorneremo nei dettagli specifici e alle conseguenze che porta nel capitolo <info:string>.
+Ad esempio, le lettere maiuscole e minuscole contano. La lettera maiuscola `"A"` non è uguale alla lettera minuscola `"a"`. Qual'è la più grande? La maggiore è  quella minuscola. Come mai? Perché le lettere minuscole hanno un indice maggiore nella tabella di encoding utilizzata JavaScript (Unicode). Ritorneremo nei dettagli specifici e alle conseguenze nel capitolo <info:string>.
 ```
 
 ## Confronti tra tipi diversi
@@ -76,15 +78,15 @@ alert( '2' > 1 ); // true, la stringa '2' diventa il numero 2
 alert( '01' == 1 ); // true, la stringa '01' diventa il numero 1
 ```
 
-Per i valori booleani, `true` diventa `1` e `false` diventa `0`, quindi:
+Per i valori di tipo booleano, `true` diventa `1` e `false` diventa `0`, quindi:
 
 ```js run
 alert( true == 1 ); // true
 alert( false == 0 ); // true
 ```
 
 ````smart header="Una conseguenza divertente"
-Questo avviene anche quando:
+E' possibile, contemporaneamente, che:
 
 - Due valori sono uguali.
 - Uno dei due è `true` come booleano e l'altro è `false` come booleano.
@@ -101,12 +103,12 @@ alert( Boolean(b) ); // true
 alert(a == b); // true!
 ```
 
-Dal punto di vista di JavaScript questo è abbastanza normale. Un controllo di uguaglianza converte sempre utilizzando la conversione numerica (quindi `"0"` diventa `0`), mentre la conversione `Boolean` utilizza altre regole.
+Dal punto di vista di JavaScript questo è abbastanza normale. Un controllo di uguaglianza converte sempre utilizzando la conversione numerica (quindi `"0"` diventa `0`), mentre la conversione esplicita a booleano `Boolean` utilizza altre regole.
 ````
 
 ## Uguaglianza stretta
 
-Un controllo di uguaglianza standard `==` ha dei problemi. Non distingue tra `0` e `false`:
+Il normale controllo di uguaglianza `==` ha dei problemi. Non distingue tra `0` e `false`:
 
 ```js run
 alert( 0 == false ); // true
@@ -118,46 +120,47 @@ La stessa cosa accade con una stringa vuota:
 alert( '' == false ); // true
 ```
 
-Questo perchè operandi di diversi tipi vengono convertiti a numeri dall'operatore di uguaglianza `==`. Una stringa vuota, come `false`, diventa zero.
+Questo perché operandi di tipo diverso vengono convertiti in numerici dall'operatore di uguaglianza `==`. Una stringa vuota, così come un booleano `false`, diventa zero.
 
 Come possiamo fare se vogliamo distinguere tra `0` e `false`?
 
 **Un operatore di uguaglianza stretta `===` controlla l'uguaglianza senza conversione di tipo.**
 
-In altre parole, se `a` e `b` sono di tipi differenti, allora `a === b` ritornerà subito `false` senza tentare di convertirli.
+In altre parole, se `a` e `b` sono di tipo differente, allora `a === b` restituirà subito `false` senza tentare di convertirli.
 
 Proviamolo:
 
 ```js run
-alert( 0 === false ); // false, perché i tipi sono differenti
+alert( 0 === false ); // false, perché il tipo è differente
 ```
 
-Esiste anche un operatore di "disuguaglianza stretta" `!==`, come analogo per l'operatore `!=`.
+Esiste anche un operatore di "disuguaglianza stretta" `!==`, analogo all'operatore `!=`.
 
 L'operatore di uguaglianza stretta è un pò più lungo da scrivere, ma rende ovvio il controllo e lascia meno spazio ad errori.
 
 ## Confronto con null e undefined
 
-Diamo un'occhiata ad ulteriori casi limite.
+C'è un comportamento poco intuitivo quando `null` o `undefined` vengono comparati con gli altri valori.
 
-C'è un comportamento non atteso quando `null` o `undefined` vengono comparati con gli altri valori.
+**Per un controllo di uguaglianza stretta `===`**
 
-Per un controllo di uguaglianza stretta `===`
-: Questi valori sono diversi, perchè ognuno di loro appartiene ad un tipo a se stante.
+Questi valori sono diversi, perché non appartengono allo stesso tipo.
 
     ```js run
     alert( null === undefined ); // false
     ```
 
-Per un controllo non stretto `==`
-: Qui c'è una regola speciale. Questi due sono una "dolce coppia": sono uguali l'uno per l'altro, ma non con gli altri valori.
+**Per un controllo non stretto `==`**
+
+Qui c'è una regola speciale. Questi due sono una "dolce coppia": tra di loro sono uguali (riferito a `==`), ma non lo sono con con nessun altro valore.
 
     ```js run
     alert( null == undefined ); // true
     ```
 
-Per confronti matematici `< > <= >=`
-: I valori `null/undefined` vengono convertiti in numeri: `null` diventa `0`, mentre `undefined` diventa `NaN`.
+**Per confronti matematici `< > <= >=`**
+
+I valori `null/undefined` vengono convertiti in numeri: `null` diventa `0`, mentre `undefined` diventa `NaN`.
 
 Adesso notiamo una cosa divertente quando proviamo ad applicare queste regole. E, cosa più importante, come non cadere in tranelli a causa di queste caratteristiche.
 
@@ -171,41 +174,40 @@ alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```
 
-Si, matematicamente può sembrare strano. L'ultimo risultato dice che "`null` è maggiore o uguale a zero". Quindi uno dei confronti sopra dovrebbe essere corretto, ma risultano entrambi falsi.
+Matematicamente questo è strano. L'ultimo risultato dice che "`null` è maggiore o uguale a zero". Quindi uno dei confronti sopra dovrebbe essere corretto, eppure risultano entrambi falsi.
 
-La ragione è che il controllo di uguaglianza `==` e di confronto `> < >= <=` lavorano diversamente. Il confronto converte `null` ad un numero, quindi lo tratta come `0`. Questo è perchè (3) `null >= 0` è vero e (1) `null > 0` è falso.
+La ragione è che il controllo di uguaglianza `==` e di confronto `> < >= <=` lavorano diversamente. Il confronto converte `null` in valore numerico, quindi lo tratta come `0`. Questo è il motivo per cui (3) `null >= 0` è vero e (1) `null > 0` è falso.
 
-D'altra parte, il controllo di uguaglianza `==` per `undefined` e `null` viene definito, senza alcuna conversione, loro sono uguali l'un l'altro ma non sono uguali a nient'altro. Questo è il motivo per cui (2) `null == 0` è falsa.
+D'altra parte, il controllo di uguaglianza `==` per `undefined` e `null` viene eseguito, come detto, senza alcuna conversione. Essi sono uguali tra di loro, ma diversi a qualsiasi altro valore. Questo è il motivo per cui (2) `null == 0` è falso.
 
 ### Undefined è incomparabile
 
-Il valore `undefined` non passa il confronto con nulla:
+Il valore `undefined` non può essere confrontato con nessun altro valore:
 
 ```js run
 alert( undefined > 0 ); // false (1)
 alert( undefined < 0 ); // false (2)
 alert( undefined == 0 ); // false (3)
 ```
 
-Perchè non va bene neanche uno zero? Sempre falso!
-
-Noi abbiamo questi risultati perchè:
+Perché non va bene neanche lo zero? E' sempre falso!
 
-- Il confronto `(1)` e `(2)` ritorna `false` perchè `undefined` viene convertito a `NaN`, mentre `NaN` è un valore numerico speciale che ritorna `false` con tutti i confronti.
-- Il confronto di uguaglianza `(3)` ritorna `false`, perchè `undefined` è uguale solo a `null`, `undefined` e a nessun altro  valore.
+Otteniamo questi risultati perché:
 
-### Eludere i problemi
+- I confronti `(1)` e `(2)` restituiscono `false` perché `undefined` viene convertito a `NaN`, e `NaN` è un valore numerico speciale che restituisce `false` in tutte le operazioni di confronto.
+- Il confronto di uguaglianza `(3)` restituisce `false`, perché `undefined` è uguale solo a `null`, `undefined`, ma a nessun altro valore.
 
-Perchè abbiamo studiato questi esempi? Dovremmo ricordarci queste caratteristiche a memoria? Bhe, in realtà no. Questo tipo di trucchetti diventeranno familiari poco alla volta, ma c'è un modo sicure per eludere i problemi che possono sorgere.
+### Evitare i problemi
 
-Semplicemente tratte tutti i confronti con `undefined/null` solo con l'operatore di uguaglianza stretta `===`.
+Perché abbiamo studiato questi esempi? Dovremmo ricordarci queste peculiarità tutte le volte? Bhe, in realtà no. Questo tipo di trucchetti diventeranno familiari col tempo, ma c'è un modo sicuro per evitare i problemi che possono sorgere:
 
-Non utilizzate i confronti `>= > < <=` con una variabile che potrebbe valere `null/undefined`, senza essere davvero sicuri di cosa state facendo. Se una variabile può avere questi tipi di valore, è buona norma eseguire un controllo separatamente.
+- Trattate tutti i confronti con `undefined/null`, ad eccezione del confronto stretto `===`, con particolare attenzione.
+- Non utilizzate i confronti `>= > < <=` con variabili che potrebbero essere `null/undefined`, se non siete più che sicuri di ciò che state facendo. Se una variabile può avere questo tipo di valore, è buona norma eseguire un controllo separatamente.
 
 ## Riepilogo
 
-- Gli operatori di confronto ritornano un valore booleano.
-- Le stringhe vengono confrontate lettera per lettera seguendo l'ordine "lessico-grafico".
-- Quando valori di tipi differenti vengono confrontati, questi vengono converiti a numeri (con eccezione per il controllo di uguaglianza stretto).
-- I valori `null` e `undefined` sono `==` solo l'uno per l'altro e a nessun altro valore.
-- Va prestata attenzione quando si utilizzano gli operatori di confronto come `>` o `<` con variabili che potrebbero contenere `null/undefined`. Una buona idea è eseguire un controllo separato per `null/undefined`.
+- Gli operatori di confronto restituiscono sempre un valore booleano.
+- Le stringhe vengono confrontate lettera per lettera seguendo l'ordine "lessicografico".
+- Quando valori di tipo differente vengono confrontati, questi vengono convertiti in numeri (ad eccezione del controllo di uguaglianza stretto).
+- I valori `null` e `undefined` sono `==` solo tra di loro, e a nessun altro valore.
+- Va prestata attenzione quando si utilizzano gli operatori di confronto come `>` o `<` con variabili che potrebbero contenere `null/undefined`. Controllare separatamente l'assegnazione di `null/undefined` è una buona idea.