Merge branch 'master' of https://github.com/javascript-tutorial/it.javascript.info into Article/13-while-for

Author: Dorin-David

1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md

@@ -4,7 +4,7 @@ La risposta: prima `1`, poi `2`.
 alert( alert(1) || 2 || alert(3) );
 ```
 
-La chiamata ad `alert` non ritorna alcun valore; dunque `undefined`.
+La chiamata ad `alert` non ritorna alcun valore; ossia `undefined`.
 
 1. Il primo OR `||` valuta l'operando sinistro `alert(1)`. Questo mostra il primo messaggio, `1`.
 2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando, alla ricerca di un valore vero.

1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md

@@ -4,4 +4,6 @@ importance: 3
 
 # Controlla l'intervallo
 
-Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` (inclusi: `age` può valere anche `14` o `90`).
+Scrivi una condizione `if` per controllare che `age` sia compresa tra `14` e `90` estremi inclusi.
+
+"Inclusi" significa che `age` può valere anche `14` o `90`.

1-js/02-first-steps/11-logical-operators/8-if-question/solution.md

@@ -3,17 +3,17 @@ La risposta: il primo e il terzo verranno eseguiti.
 I dettagli:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
+// Viene eseguito
+// Il risultato di -1 || 0 = -1 è vero
 if (-1 || 0) alert( 'first' );
 
-// Doesn't run
-// -1 && 0 = 0, falsy
+// Non viene eseguito
+// -1 && 0 = 0, falso
 if (-1 && 0) alert( 'second' );
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Eseguito
+// L'operatore && ha la precedenza su ||,
+// quindi -1 && 1 vengono eseguiti per primi; la catena dentro `if` diventa:
 // null || -1 && 1  ->  null || 1  ->  1
 if (null || -1 && 1) alert( 'third' );
 ```

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

@@ -16,7 +16,7 @@ result = a || b;
 
 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.
+In JavaScript questo operatore è un po' più potente. Ma prima vediamo come si comporta con i valori booleani.
 
 Ci sono quattro combinazioni logiche possibili:
 
@@ -29,7 +29,7 @@ alert( false || false ); // false
 
 Come possiamo vedere, il risultato è sempre `true`, tranne nei casi in cui entrambi gli operandi sono `false`.
 
-Se un operando non è di tipo booleano vi viene momentaneamente convertito per la valutazione.
+Se un operando non è di tipo booleano, allora viene momentaneamente convertito per la valutazione.
 
 Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`:
 
@@ -82,7 +82,7 @@ L'operatore OR `||` si comporta come segue:
 - 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.
+Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.
 
 In altre parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore.
 
@@ -119,7 +119,7 @@ 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. 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. 
+    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, il quale viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perché cerca di concludersi il prima possibile, senza dover elaborare tutti gli operandi. 
 
     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. 
@@ -258,7 +258,7 @@ result = !value;
 L'operatore accetta un solo argomento e si comporta come segue:
 
 1. Converte l'operando a booleano: `true/false`.
-2. Ritorna il valore **inverso.
+2. Ritorna il valore inverso.
 
 Ad esempio:
 
@@ -276,7 +276,7 @@ alert( !!null ); // false
 
 Quello che accade è che il primo NOT converte l'operando a booleano e ritorna il suo inverso, e il secondo NOT lo *inverte nuovamente*. Il risultato è un valore di tipo booleano.
 
-C'è un modo molto più lungo per fare la stessa cosa -- una funzione *built-in* di `Boolean`:
+C'è un modo molto più lungo per fare la stessa cosa, usare la funzione `Boolean`, integrata in JavaScript:
 
 ```js run
 alert( Boolean("non-empty string") ); // true

1-js/02-first-steps/14-switch/article.md

@@ -47,7 +47,7 @@ switch (a) {
     break;
 */!*
   case 5:
-    alert( 'Too large' );
+    alert( 'Too big' );
     break;
   default:
     alert( "I don't know such values" );

1-js/03-code-quality/04-ninja-code/article.md

@@ -2,7 +2,7 @@
 
 
 ```quote author="Confucio"
-Imparare senza pensare è lavoro sprecata; pensare senza imparare è pericoloso.
+Imparare senza pensare è lavoro sprecatao; pensare senza imparare è pericoloso.
 ```
 I programmatori ninja in passato hanno usato queste tecniche per formare le menti dei manutentori del codice.
 
@@ -41,9 +41,9 @@ Insegnategli che la brevità è sempre la cosa migliore. Iniziatelo al percorso
 Il Dao si nasconde nel silenzio. Solo il Dao è completo.
 ```
 
-Un altro metodo per programmare velocemente è utilizzare nomi di variabili a singola carattere ovunque. Come `a`, `b` o `c`.
+Un altro metodo per programmare velocemente è utilizzare nomi di variabili a singolo carattere ovunque. Come `a`, `b` o `c`.
 
-Una variabile molto breve sparirà nel codice come un vero ninja scompare nella foresta. Nessuno sarà in grado di ritrovarla, nemmeno utilizzando il tasto "cerca". E se qualcuno mai riuscirà a trovarla non "decifrerà" ma il vero significato di `a` o `b`.
+Una variabile molto breve sparirà nel codice come un vero ninja scompare nella foresta. Nessuno sarà in grado di ritrovarla, nemmeno utilizzando il tasto "cerca". E se qualcuno mai riuscirà a trovarla non "decifrerà" mai il vero significato di `a` o `b`.
 
 ...C'è però un'eccezione. Un vero ninja non utilizzerà mai `i` come contatore in un ciclo `"for"`. Ovunque, ma non qui. Si guarderà intorno, ci sono moltissime lettere esotiche. Ad esempio `x` o `y`.
 

1-js/03-code-quality/05-testing-mocha/article.md

@@ -32,7 +32,7 @@ Abbiamo parlato abbastanza. Vediamo degli esempi.
 
 ## Sviluppo di "pow": le specifiche
 
-Vogloamo creare una funzione `pow(x, n)` che calcola la potenza di `x` per un intero `n`. Assumiamo che `n≥0`.
+Vogliamo creare una funzione `pow(x, n)` che calcola la potenza di `x` per un intero `n`. Assumiamo che `n≥0`.
 
 Questo è solo un esempio: infatti l'operatore `**` svolge quest'azione, ma concentriamoci sul flusso di sviluppo, che potremmo poi applicare a funzioni più complesse.
 
@@ -56,7 +56,7 @@ Una spec ha tre principali blocchi:
 : Viene descritta la funzionalità. Utilizzata per raggruppare le "attività" -- i blocchi `it`. Nel nostro caso descriviamo la funzione `pow`.
 
 `it("title", function() { ... })`
-: Nel titolo di `it` descriviamo il particolare caso d'uso *leggibili per gli umani*, come secondo argomento una funzione che la testa.
+: Nel titolo di `it` descriviamo il particolare caso d'uso *leggibile per gli umani*, come secondo argomento una funzione che lo testa.
 
 `assert.equal(value1, value2)`
 : Il codice all'interno del blocco `it`, se l'implementazione è corretta, dovrebbe eseguire senza errori.
@@ -79,14 +79,14 @@ Il flusso di sviluppo solitamente segue i passi:
 
 Quindi la fase di sviluppo è *iterativa*. Scriviamo la specifica, la implementiamo, ci accertiamo che passi i test, ci assicuriamo che faccia ciò che deve. Al termine di questa procedura avremmo un implementazione già testata e funzionante.
 
-Nel nostro caso, il primo step è completo: abbiamo un specifica iniziale di `pow`. Quindi ora passiamo all'implementazione. Come prima cosa facciamo l'esecuzione "zero" con le specifiche scritte, per essere sicuri che tutto funzioni (ovviamente dovrebbero tutte fallire).
+Nel nostro caso, il primo step è completo: abbiamo un specifica iniziale di `pow`. Quindi ora passiamo all'implementazione. Come prima cosa facciamo l'esecuzione "zero" con le specifiche scritte, per essere sicuri che tutto funzioni (ovviamente i test dovrebbero fallire tutti).
 
 ## La spec in azione
 
 In questo guida utilizzeremo le seguenti librerie JavaScript per fare test:
 
 - [Mocha](http://mochajs.org/) -- un core framework: fornisce le maggiori funzioni di test come `describe` e `it` e le principali funzioni che eseguono i test.
-- [Chai](http://chaijs.com) -- una libreria con molte asserzioni. Ci consente di utilizzare molte asserzioni differenti, per ora ci servirà solo s`assert.equal`.
+- [Chai](http://chaijs.com) -- una libreria con molte asserzioni. Ci consente di utilizzare molte asserzioni differenti, per ora ci servirà solamente `assert.equal`.
 - [Sinon](http://sinonjs.org/) -- una libreria per il controllo oltre le funzioni, emula funzioni integrate e molto altro, la utilizzeremo più avanti.
 
 Queste librerie sono utili sia per per il test browser, sia per il test lato server. Qui considereremo la variante browser.
@@ -296,14 +296,14 @@ Testing finished – after all tests (after)
 
 [edit src="beforeafter" title="Open the example in the sandbox."]
 
-Solitamente, `beforeEach/afterEach` (`before/each`) vengono utilizzari per eseguire inizializzazioni, azzerare i contatori o fare qualcosa prima di iniziare il prossimo test.
+Solitamente, `beforeEach/afterEach` (`before/each`) vengono utilizzati per eseguire inizializzazioni, azzerare i contatori o fare qualcosa prima di iniziare il prossimo test.
 ````
 
 ## Estendere le spec
 
 La funzionalità di base di `pow` è completa. La prima iterazione di sviluppo è fatta. Dopo aver festeggiato e bevuto champagne -- andiamo avanti provando ad aggiungere funzionalità.
 
-Come abbiamo detto, la funzione `pow(x, n)` è stata sviluppate per funzionare con interi positivi `n`.
+Come abbiamo detto, la funzione `pow(x, n)` è stata sviluppata per funzionare con interi positivi `n`.
 
 Per indicare un errore matematico, JavaScript solitamente ritorna `NaN`. Facciamo lo stesso per valori non validi di `n`.
 
@@ -332,7 +332,7 @@ Il risultato con il nuovo test sarà:
 
 [iframe height=530 src="pow-nan" edit border="1"]
 
-I nuovi test aggiunti falliranno, perché la nostra implementazione non li supporta ancora. Cosi è come funziona BDD: prima si scrivono test fallaci, e successivamente si lavora sull'implementazione.
+I nuovi test aggiunti falliranno, perché la nostra implementazione non li supporta ancora. Cosi è come funziona BDD: prima si scrivono test in modo che falliscano, e successivamente si lavora sull'implementazione.
 
 ```smart header="Altre asserzioni"
 
@@ -390,7 +390,7 @@ Questo è particolarmente importante specie nei grandi progetti, quando le funzi
 Senza i test, le persone avrebbero due possibilità:
 
 1. Cambiare qualcosa, non importa cosa. E successivamente gli utenti dovrebbero fare un rapporto quando incontrano un bug. Non sempre possiamo permetterci di farlo.
-2. Essere impauriti dai cambiamenti, soprattutto se la punizione in caso di errori è severa. Un giorno queste funzioni diventeranno vecchie, e coperte di ragnatele, nessuno vorrebbe utilizzare, questa opzione non è quindi ottimale.
+2. Essere impauriti dai cambiamenti, soprattutto se la punizione in caso di errori è severa. Un giorno queste funzioni diventeranno vecchie, e coperte di ragnatele, nessuno vorrà più utilizzarle, questa opzione non è quindi ottimale.
 
 **Il codice testato automaticamente evita questi problemi!**
 

1-js/03-code-quality/06-polyfills/article.md

@@ -1,15 +1,17 @@
 
-# Polyfills and transpilers
+# Polyfills e transpilers
 
 Il linguaggio JavaScript si evolve costantemente. Nuove proposte per il linguaggio arrivano regolarmente, vengono analizzate, e successivamente se ritenute valide vengono aggiunte alla lista <https://tc39.github.io/ecma262/> fino a diventare delle [specifiche](http://www.ecma-international.org/publications/standards/Ecma-262.htm).
 
 I team che stanno dietro il motore di JavaScript hanno le loro personali idee riguardo cosa implementare. Potrebbero quindi decidere di implementare delle proposte recenti e posticipare quelle più vecchie a causa di difficoltà nell'implementazione.
 
 Quindi per un motore di script è naturale implementare solo le cose che si trovano nello standard.
 
-Se si vuole rimanere aggiornati riguardo lo stato di supporto delle caratteristiche si può controllare la pagina <https://kangax.github.io/compat-table/es6/> (è molt grande, dovremmo studiare ancora molto).
+Se si vuole rimanere aggiornati riguardo lo stato di supporto delle caratteristiche si può controllare la pagina <https://kangax.github.io/compat-table/es6/> (è molto grande, dovremmo studiare ancora molto).
 
-Come programmatori, amiamo utilizzare le più recenti caratteristiche del linguaggio, ma come si può fare per farle funzionare sui vecchi motori Javascript che non le comprendono ed interpretano?
+Come programmatori, amiamo utilizzare le più recenti caratteristiche del linguaggio!
+
+Ma come si può fare per farle funzionare sui vecchi motori JavaScript che non le comprendono ed interpretano?
 
 Esistono due strumenti per questo:
 
@@ -20,7 +22,7 @@ In questo capitolo cercheremo di capire il loro funzionamento ed il loro ruolo n
 
 ## Transpilers
 
-Un [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) è un particolare software capace di analizzare il codice moderno e di riscriverlo utilizzando sintassi e costrutti meno recenti, facendo in modo che alla fine funzioni nello stesso modo.
+Un [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) è un particolare software capace di analizzare il codice moderno e di riscriverlo utilizzando sintassi e costrutti meno recenti, facendo in modo che il funzionamento sia simile.
 
 Es. JavaScript prima del 2020 non aveva "l'operatore di coalescenza nullo" `??`. Quindi, se un visitatore utilizza un vecchio browser, questo non potrebbe comprendere `height = height ?? 100`.
 
@@ -34,7 +36,7 @@ height = height ?? 100;
 height = (height !== undefined && height !== null) ? height : 100;
 ```
 
-Ora il codice riscritto è adatto anche ai vecchi motori JavaScript
+Ora il codice riscritto è adatto anche ai vecchi motori JavaScript.
 
 In genere lo sviluppatore fa girare il transpiler in locale sul proprio computer, quindi distribuisce sul server il codice riscritto.
 

1-js/04-object-basics/01-object/article.md

@@ -36,7 +36,7 @@ Nell'oggetto `user`, ci sono due proprietà:
 1. La prima proprietà ha come nome `"name"` e valore `"John"`.
 2. La seconda come nome ha `"age"` e valore `30`.
 
-L'oggetto risultate `user` può essere visto come un archivio con due file etichettati con "name" ed "age".
+L'oggetto `user` risultante può essere visto come un archivio con due file etichettati con "name" ed "age".
 
 ![user object](object-user.svg)