Merge pull request #220 from longo-andrea/review/numbers

reviewed article and exercises

Author: longo-andrea

1-js/05-data-types/02-number/1-sum-interface/task.md

@@ -4,9 +4,9 @@ importance: 5
 
 # Sommate i numeri forniti dall'utente
 
-Create uno script che richiede due numeri all'utente (tramite prompt) e successivamente mostrate la somma.
+Create uno script che richiede due numeri all'utente (tramite prompt) e successivamente mostra la somma.
 
 [demo]
 
-P.S. Attenzione alla cattura dei tipi.
+P.S. Fate attenzione ai tipi.
 

1-js/05-data-types/02-number/3-repeat-until-number/solution.md

@@ -19,5 +19,5 @@ La soluzione risulta essere leggermente più complessa poiché è necessario tra
 
 In questo modo possiamo quindi accettare input finché non viene inserito un "numero valido". Sia `null` (cancel) sia una riga vuota soddisfano questa condizione, poiché la loro forma numerica vale `0`.
 
-Dopo esserci fermati, abbiamo bisogno di di gestire i casi `null` e righa vuota diversamente (ritornando `null`), poichè convertirli alla forma numerica li "trasformerrebbe" in `0`.
+Dopo esserci fermati, abbiamo bisogno di di gestire i casi `null` e righa vuota diversamente (ritornando `null`), poiché convertirli alla forma numerica li "trasformerrebbe" in `0`.
 

1-js/05-data-types/02-number/4-endless-loop-error/solution.md

@@ -1,4 +1,4 @@
-Questo accede perché `i` non sarà mai uguale `10`.
+Questo accade perché `i` non sarà mai uguale `10`.
 
 Eseguitelo per vedere il *vero* risultato di `i`:
 

1-js/05-data-types/02-number/8-random-min-max/solution.md

@@ -2,7 +2,7 @@ Abbiamo bisogno di far "scorrere" 'intervallo da 0..1 a `min`.. `max`.
 
 Questo può essere ottenuto con due passi:
 
-1. Se moltiplichiamo un numero casuale compreso tra 0..1 per `max-min`, l'intervallo dei possibili valori crese da `0..1` a `0..max-min`.
+1. Se moltiplichiamo un numero casuale compreso tra 0..1 per `max-min`, l'intervallo dei possibili valori cresce da `0..1` a `0..max-min`.
 2. Ora se aggiungiamo `min`, il possibile intervallo si estende da `min` a `max`.
 
 La funzione:

1-js/05-data-types/02-number/8-random-min-max/task.md

@@ -6,7 +6,7 @@ importance: 2
 
 La funzione integrata `Math.random()` crea un valore random compreso tra `0` e `1` (`1` escluso).
 
-scrivete la funzione `random(min, max)` per generare un numero random in virgola mobile che va da `min` a `max` (`max` escluso).
+Scrivete la funzione `random(min, max)` per generare un numero random in virgola mobile che va da `min` a `max` (`max` escluso).
 
 Esempi:
 

1-js/05-data-types/02-number/article.md

@@ -22,7 +22,7 @@ Possiamo anche usare il carattere underscore `_` come separatore:
 let billion = 1_000_000_000;
 ```
 
-Qui il carattere `_` gioca il ruolo di "szucchero sintattico", cioè rende il numero più leggibile. Il motore JavaScript semplicemente ignorerà i caratteri `_` tra le cifre, quindi è come scrive il milione di poco sopra.
+Qui il carattere `_` gioca il ruolo di "zucchero sintattico", cioè rende il numero più leggibile. Il motore JavaScript semplicemente ignorerà i caratteri `_` tra le cifre, quindi è equivalente al milione scritto sopra.
 
 Nella vita reale però cerchiamo di evitare di scrivere lunghe file di zeri per evitare errori. E anche perché siamo pigri. Solitamente scriviamo qualcosa del tipo `"1ml"` per un milione o `"7.3ml"` 7 milioni e 300mila. Lo stesso vale per i numeri più grandi.
 
@@ -38,8 +38,8 @@ In altre parole, `"e"` moltiplica il numero `1` seguito dal numero di zeri dati.
 
 
 ```js
-1e3 = 1 * 1000 // e3 means *1000
-1.23e6 = 1.23 * 1000000 // e6 means *1000000
+1e3 = 1 * 1000 // e3 significa *1000
+1.23e6 = 1.23 * 1000000 // e6 significa *1000000
 ```
 
 Ora proviamo a scrivere qualcosa di molto piccolo. Ad esempio, 1 microsecondo (un milionesimo di secondo): 
@@ -91,7 +91,7 @@ Ci sono solo 3 sistemi di numerazione con questo livello di supporto. Per gli al
 
 ## toString(base)
 
-Il metodo `num.toString(base)` ritorna una rappresentazione in stringa del numero `num` con il sistema numerazione fornito `base`.
+Il metodo `num.toString(base)` ritorna una rappresentazione in stringa del numero `num` con il sistema di numerazione fornito `base`.
 
 Ad esempio:
 ```js run
@@ -150,7 +150,7 @@ Qui abbiamo una tabella che riassume le principali differenze:
 |`-1.6`|  `-2`    |   `-1`  |    `-2`  |   `-1`   |
 
 
-Queste funzioni coprono tutti i possibili casi quando trattiamo numeri con una parte decimale. Come potremmo fare se volessi arrotondare il numero ad `n` cifre dopo la virgola?
+Queste funzioni coprono tutti i possibili casi quando trattiamo numeri con una parte decimale. Come potremmo fare se volessimo arrotondare il numero ad `n` cifre dopo la virgola?
 
 Ad esempio, abbiamo `1.2345` e vogliamo arrotondarlo a due cifre dopo la virgola, tenendo solo `1.23`.
 
@@ -214,7 +214,7 @@ Strano! Quale può essere il risultato se non `0.3`?
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
-Ouch! Ci possono essere molte conseguenze dovute ad un errato confronto. Immaginate di progettare un sito di e-shop in cui i visitatori aggiungono al carrello articoli da `$0.10` e `$0.20`. Poi come prezzo totale viene mostrato `$0.30000000000000004`. Questo risultato lascerebbe sorpreso chiunque.
+Ouch! Un confronto errato di questo tipo può generare diverse conseguenze. Immaginate di progettare un sito di e-shop in cui i visitatori aggiungono al carrello articoli da `$0.10` e `$0.20`. Poi come prezzo totale viene mostrato `$0.30000000000000004`. Questo risultato lascerebbe sorpreso chiunque.
 
 Ma perché accade questo?
 
@@ -252,7 +252,7 @@ let sum = 0.1 + 0.2;
 alert( sum.toFixed(2) ); // 0.30
 ```
 
-    Da notare che `toFixed` ritorna sempre una stringa. Viene cosi garantito che ci siano almeno due cifre dopo la virgola decimale. Questo ci torna molto utile se abbiamo un e-shopping e vogliamo mostrare `$0.30`. Per tutti gli altri casi possiamo semplicemente chiamare la conversione con l'operatore di somma unaria:
+Da notare che `toFixed` ritorna sempre una stringa. Viene cosi garantito che ci siano almeno due cifre dopo la virgola decimale. Questo ci torna molto utile se abbiamo un e-shopping e vogliamo mostrare `$0.30`. Per tutti gli altri casi possiamo semplicemente chiamare la conversione con l'operatore di somma unaria:
 
 ```js run
 let sum = 0.1 + 0.2;
@@ -266,13 +266,13 @@ alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
 alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001
 ```
 
-    Questo funziona perché quando facciamo `0.1 * 10 = 1` e `0.2 * 10 = 2` entrambi diventano interi, non vi è quindi perdita di precisione. 
+Questo funziona perché quando facciamo `0.1 * 10 = 1` e `0.2 * 10 = 2` entrambi diventano interi, non vi è quindi perdita di precisione. 
 
-3. Se abbiamo a che fare con dei prezzi, la miglior soluzione rimane quella di memorizzare tutti i prezzi in centesimi, evitando quindi di utilizzare i numeri con virgola. Ma cosa succede se proviamo ad applicare uno sconto del 30%? Nella pratica, evadere completamente questo problema è difficile, in alcuni casi possono tornare utili entrambe le soluzioni viste sopra.
+3. Se abbiamo a che fare con dei prezzi, la miglior soluzione rimane quella di memorizzare tutti i prezzi in centesimi, evitando quindi di utilizzare i numeri con virgola. Ma cosa succede se proviamo ad applicare uno sconto del 30%? Nella pratica, evitare completamente questo problema è difficile, in alcuni casi possono tornare utili entrambe le soluzioni viste sopra.
 
 Quindi, l'approccio moltiplicazione/divisione riduce gli errori, ma non li elimina completamente.
 
-Talvolta possiamo evitare le frazioni. Ad esempio se abbiamo a che fare con un negozio, allora possiamo memorizzare i prezzi in centesimi piuttosto che in dollari.  
+Talvolta possiamo evitare le frazioni. Ad esempio se abbiamo a che fare con un negozio, allora possiamo memorizzare i prezzi in centesimi piuttosto che in euro.
 
 ````smart header="La cosa divertente"
 Provate ad eseguire questo:
@@ -424,7 +424,7 @@ Un paio di esempi:
 
 Ci sono molte altre funzioni e costanti nell'oggetto `Math`, incluse quelle trigonometriche, che potete trovare nella [documentazione dell'oggetto Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math).
 
-``````
+
 ## Riepilogo
 
 Per scrivere numeri molto grandi:
@@ -434,12 +434,14 @@ Per scrivere numeri molto grandi:
 
 Per diversi sistemi numerici:
 
-Per convertire a numeri valori del tipo `12pt` e `100px`:
-
 - Potete scrivere direttamente in esadecimale (`0x`), ottale (`0o`) e binario (`0b`) 
 - `parseInt(str, base)` analizza un numero intero con un qualsiasi sistema numerico con base: `2 ≤ base ≤ 36`.
 - `num.toString(base)` converte un numero ad una stringa utilizzando il sistema numerico fornito in `base`.
 
+Per convertire a numeri valori del tipo `12pt` e `100px`:
+
+- Utilizzate parseInt/parseFloat per un conversione "soft", i quali provano a leggere un numero da una stringa e ritornano ciò che sono riusciuti ad estrarre prima di interrompersi.
+
 Per i numeri con la virgola:
 
 - Arrotondate usando `Math.floor`, `Math.ceil`, `Math.trunc`, `Math.round` o `num.toFixed(precision)`.
@@ -449,4 +451,3 @@ Altre funzioni matematiche:
 
 - Guardate l'oggetto [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) in caso di necessità. La libreria non è molto ampia, ma è in grado di coprire le necessità di base.
 
-