Merge branch 'master' of https://github.com/javascript-tutorial/it.javascript.info into hotfix-conflicts

Author: pasor1

1-js/02-first-steps/01-hello-world/1-hello-alert/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Crea un pagina che mostra un messaggio "I'm JavaScript".
 
-Provalo tramite la sandbox, oppure sul tuo hard disk, assicurati solo che funzioni.
+Provalo tramite la sandbox, oppure sul tuo hard disk, non ha importanza, assicurati solo che funzioni.
 
 [demo src="solution"]
 

1-js/02-first-steps/01-hello-world/article.md

@@ -1,10 +1,10 @@
 # Hello, world!
 
-Il seguente tutorial tratta del core (nucleo) JavaScript, che è indipendente dalla piattaforma.
+Il seguente tutorial tratta del core (nucleo) di JavaScript, il quale è indipendente dalla piattaforma.
 
-Abbiamo bisogno di un ambiente di lavoro per eseguire i nostri script, e il fatto che questo libro sia online, rende il browser un ottima scelta. Cercheremo di mantenere al minimo l'utilizzo dei comandi specifici per browser (come `alert`), cosi non dovrai perdere la testa se deciderai di spostarti in altri ambienti come Node.JS. In ogni caso, i dettagli browser vengono spiegati in dettaglio nella [prossima parte](/ui) del tutorial.
+Abbiamo bisogno di un ambiente di lavoro per eseguire i nostri script, e il fatto che questo tutorial sia online, rende il browser un ottima scelta. Cercheremo di mantenere al minimo l'utilizzo dei comandi specifici per browser (come `alert`), cosi non dovrai perdere la testa se deciderai di spostarti in altri ambienti (come Node.jd). In ogni caso, ci concentreremo sulle caratteristiche JavaScript specifiche per il browser nella [prossima parte](/ui) del tutorial.
 
-Quindi prima di tutto, vediamo come inserire uno script in una pagina web. Per ambienti server-side, è sufficiente eseguirli con un comando come `"node my.js"` in Node.JS.
+Quindi prima di tutto, vediamo come inserire uno script in una pagina web. Per ambienti server-side (come Node.js), è sufficiente eseguirli con un comando come `"node my.js"`.
 
 ## Il tag "script"
 
@@ -37,45 +37,51 @@ Ad esempio:
 Puoi eseguire l'esempio cliccando su "Play" tramite il bottone in altro a destra.
 ```
 
-Il tag `<script>` contiene codice JavaScript che viene automaticamente eseguito quando il browser incontra il tag.
+Il tag `<script>` contiene codice JavaScript che viene automaticamente eseguito quando il browser processa il tag.
 
 ## La segnatura moderna
 
 Il tag `<script>` ha un paio di attributi che vengono utilizzati raramente, ma è comunque possibile trovarli nei vecchi codici:
 
- L'attributo `type`: <code>&lt;script <u>type</u>=...&gt;</code>
+L'attributo `type`: <code>&lt;script <u>type</u>=...&gt;</code>
+: Il precedente standard HTML, HTML4, richiedeva che lo script avesse una proprietà `type`. Solitamente era `type="text/javascript"`. Ora non è più richiesto. Inoltre, lo standard attuale HTML, ha completamente cambiato il suo significato. Ora può essere utilizzato per i moduli JavaScript. Ma questo è un argomento avanzato, parleremo dei moduli più avanti nel tutorial.
 
-: Nei più vecchi libri, è possibile trovare un commento all'interno dell'elemento `<script>`, come segue:
+L'attributo `language`: <code>&lt;script <u>language</u>=...&gt;</code>
+: Questo attributo aveva lo scopo di mostrare il linguaggio utilizzato dallo script. Ora questo linguaggio non ha più molto senso, poiché JavaScript è il linguaggio utilizzato di default. Quindi non ha più senso utilizzarlo.
+
+I commenti prima e dopo gli script.
+: Nei vecchi libri e tutorial, potreste trovare commenti all'interno del tag `<script>`, come questo:
 
     ```html no-beautify
     <script type="text/javascript"><!--
         ...
     //--></script>
     ```
 
-    Questo trucco non viene più utilizzato nel moderno JavaScript. I commenti venivano utilizzati per nascondere il codice JavaScript dai vecchi browser che non conoscevano il tag `<script>`.I browser rilasciati negli utlimi 15 anni non hanno questo problema, questo tipo di strategia può aiutarti a riconsocere i vecchi codici.
+    Questo trucco non viene più utilizzato. Questi commenti avevano lo scopo di nascondere il codice JavaScript ai vecchi browser che non erano in grado di elaborare il tag `<script>`. Poiché i browser rilasciati negli ultimi 15 anni non hanno più questo problema, questo tipo di commenti possono aiutarti ad identificare codici molto vecchi.
+
 
 ## Script esterni
 
 Se abbiamo molto codice JavaScript, possiamo inserirlo in un file separato.
 
-Il file dello script viene integrato nel codice HTML tramtie l'attributo `src`:
+Il file dello script viene integrato nel codice HTML tramite l'attributo `src`:
 
 ```html
 <script src="/path/to/script.js"></script>
 ```
 
-Questo `/path/to/script.js` è il percorso assoluto al file che contiene lo script (dalla root del sito).
+Questo `/path/to/script.js` è il percorso assoluto al file che contiene lo script a partire dalla root del sito. Ad esempio, `src="script.js"` significherebbe un file `"script.js"` che si trova nella cartella corrente.
 
 E' anche possibile fornire un percorso relativo a partire dalla pagina corrente. Per esempio `src="script.js"` significa che il file `"script.js"` si trova nella cartella corrente.
 
-Possiamo anche fornire un URL. Per esempio:
+Possiamo anche fornire un URL. Ad esempio:
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
-Per integrare più script, utilzzate più volte il tag:
+Per integrare più script, possiamo utilizzare più volte il tag:
 
 ```html
 <script src="/js/script1.js"></script>
@@ -88,9 +94,9 @@ Come regola da seguire, solo gli script molto semplici vanno inseriti all'intern
 
 Il beneficio di inserire gli script in file separati è che il browser andrà a scaricarli e li memorizzerà nella sua [cache](https://en.wikipedia.org/wiki/Web_cache).
 
-Cosi facendo, le altre pagine che vorranno utilizzare lo stesso script lo preleveranno dallacache invece che riscaricarlo. Quindi il file verrà scaricato una sola volta.
+Cosi facendo, le altre pagine che vorranno utilizzare lo stesso script lo preleveranno dalla cache invece che riscaricarlo. Quindi il file verrà scaricato una sola volta.
 
-Questo risparmierà traffico e renderà le pagine più veloci.
+Questo risparmierà traffico e renderà il caricamento delle pagine più veloce.
 ```
 
 ````warn header="Se `src` è impostato, il contenuto all'interno di script verrà ignorato."
@@ -100,11 +106,11 @@ Questo non funziona:
 
 ```html
 <script *!*src*/!*="file.js">
-  alert(1); // il contenuto viene ignorato, perchè src è impostato
+  alert(1); // il contenuto viene ignorato, perché src è impostato
 </script>
 ```
 
-Dobbiamo scegliere: o esterno `<script src="…">` o il semplice tag `<script>` con all'interno il codice.
+Dobbiamo scegliere fra le due possibilità: script esterno `<script src="…">` o il semplice tag `<script>` con all'interno il codice.
 
 L'esempio precedete può essere diviso in due script:
 
@@ -118,7 +124,7 @@ L'esempio precedete può essere diviso in due script:
 ## Riepilogo
 
 - Possiamo usare il tag `<script>` per aggiungere codice JavaScript alla pagina.
-- Gli attributi `type` e `language` non sono richiesti.
+- Gli attributi `type` e `language` non sono più richiesti.
 - Uno script in un file esterno può essere inserito con `<script src="path/to/script.js"></script>`.
 
-C'e ancora molto da imparare riguaro gli script browser e la loro interazione con le pagine web. Ma tenete a mente che questa parte del tutorial è dedicata al linguaggio JavaScript, quindi non dobbiamo distrarci da questo obbiettivo. Andremo ad utilizzare il browser come piattaforma in cui eseguire JavaScript, che è molto utile, ma è solo uno dei tanti modi. 
+C'e ancora molto da imparare riguardo gli script browser e la loro interazione con le pagine web. Ma tenete a mente che questa parte del tutorial è dedicata al linguaggio JavaScript, quindi non dobbiamo distrarci da questo obbiettivo. Andremo ad utilizzare il browser come piattaforma in cui eseguire JavaScript, che è molto comodo, ma è solo uno dei tanti modi. 

1-js/02-first-steps/02-structure/article.md

@@ -1,16 +1,16 @@
 # Struttura del codice
 
-La prima cosa da studiare riguarda la struttura del codice.
+La prima cosa che studieremo riguarda la struttura del codice.
 
 ## Istruzioni
 
-Le istruzioni sono dei costrutti sintattici e comandi che eseguono azioni.
+Le istruzioni sono dei costrutti sintattici e comandi che permettono di eseguire azioni.
 
 Abbiamo già visto un'istruzione `alert('Hello, world!')`, che mostra il messaggio "Hello world!".
 
-All'interno del codice possiamo avere tutte le istruzioni che desideriamo. Una seconda istruzione può essere separata tramite il punto e virgola.
+All'interno del codice possiamo avere tutte le istruzioni che desideriamo. Le istruzioni possono essere separate da un punto e virgola.
 
-Ad esempio, qui dividiamo il messaggio in due:
+Ad esempio, qui dividiamo il messaggio in due alert:
 
 ```js run no-beautify
 alert('Hello'); alert('World');
@@ -33,7 +33,7 @@ alert('Hello')
 alert('World')
 ```
 
-Qui JavaScript interpreta la fine della riga come un punto e virgola "implicito". Viene anche chiamato [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
+In questo caso, JavaScript interpreta la fine della riga come un punto e virgola "implicito". Viene anche chiamata [inserimento automatico del punto e virgola](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
 
 **In molti casi la nuova riga viene interpretata come un punto e virgola implicito. Ma "in molti casi" non significa "sempre"!**
 
@@ -45,9 +45,9 @@ alert(3 +
 + 2);
 ```
 
-Il codice stampa `6` perchè JavaScript non inserisce un punto e virgola qui. E' abbastanza ovvio che se la riga finisce con un `"+"`, allora è un "espressione incompleta", quindi il punto e virgola non è richiesto. Quindi in questo caso tutto funziona come dovrebbe.
+Il codice stampa `6` perché, in questo caso, JavaScript non inserisce un punto e virgola. E' abbastanza ovvio che se la riga finisce con un `"+"`, allora è un "espressione incompleta", quindi il punto e virgola non verrà inserito. Per questo, nell'esempio sopra, tutto funziona come dovrebbe.
 
-**Ma ci sono casi in cui JavaScript "fallisce"  But there are situations where JavaScript "fails" nell'interpretare un punto e virgola.**
+**Ma ci sono casi in cui JavaScript "fallisce" nell'interpretare un punto e virgola, dove invece sarebbe necessario.**
 
 Gli errori di questo tipo sono molto difficili da trovare e sistemare.
 
@@ -58,7 +58,7 @@ Se sei curioso di vedere un esempio concreto di questo tipo di errore, dai un oc
 [1, 2].forEach(alert)
 ```
 
-Non c'e bisogno di pensare al significato delle parentesi `[]` e al `forEach`. Li studieremo più avanti, per ora è sufficiente sapere il risultato: che mostrerà `1` e poi `2`.
+Non c'e bisogno di pensare al significato delle parentesi `[]` e al `forEach`. Li studieremo più avanti, per ora è sufficiente sapere il risultato: mostrerà `1` e poi `2`.
 
 Adesso andiamo ad aggiungere un `alert` prima del codice e *non* concludiamo la riga con il punto e virgola:
 
@@ -70,7 +70,7 @@ alert("There will be an error")
 
 Adesso se lo eseguiamo, solo il primo `alert` viene mostrato, poi avremmo un errore!
 
-Ma tutto si risolve se aggiungiamo un punto e virgola dopo `alert`:
+Ma tutto si risolve aggiungendo un punto e virgola dopo `alert`:
 ```js run
 alert("All fine now");
 
@@ -79,40 +79,40 @@ alert("All fine now");
 
 Adesso avremmo il messaggio "All fine now", successivamente `1` seguito da `2`.
 
-L'errore nel non aver messo il punto e virgola è avvenuto perchè JavaScript non inserisce automaticamente un punto e virgola prima delle parentesi quadre `[...]`.
+L'errore nel non aver messo il punto e virgola è avvenuto perché JavaScript non inserisce automaticamente un punto e virgola prima delle parentesi quadre `[...]`.
 
-Quindi, poichè il punto e virgola non viene auto-inserito, il codice del precedente esempio viene trattato come un istruzione singola. Quindi il motore JavaScript lo vede cosi:
+Quindi, poiché il punto e virgola non viene auto-inserito, il codice del precedente esempio viene trattato come un istruzione singola. Infatti il motore JavaScript lo vede cosi:
 
 ```js run no-beautify
 alert("There will be an error")[1, 2].forEach(alert)
 ```
 
-Anche se dovrebbero essere due istruzioni separate, non una singola. Questo tipo di unione, in questo caso è errata, quindi produce un errore. Ci sono altre situazioni in cui si verifica questo tipo di errore.
+Anche se se in realtà sono due istruzioni separate, non una singola. Questo tipo di interpretazione, in questo caso è errata. Ci possono essere altre situazioni in cui si verifica questo tipo di errore.
 ````
 
-E' consigliato quindi, di mettere il punto e virgola fra ogni istruzione, anche se vengono scritte in righe diverse. Questa regola è largamente adottata dalla community. Ripetiamolo nuovamente -- *è possibile* evitare di scrivere il punto e virgola la maggior parte delle volte. Ma è più sicuro -- specialmente per un novizio -- inserirle al termine di ogni istruzione.
+E' consigliato quindi, di inserire il punto e virgola fra ogni istruzione, anche se vengono scritte in righe diverse. Questa è una regola largamente adottata dalla community. Ripetiamolo nuovamente -- *è possibile* omettere il punto e virgola la maggior parte delle volte. Ma è più sicuro -- specialmente per un novizio -- inserirlo al termine di ogni istruzione.
 
 ## Commenti
 
-Con il passare del tempo, i programmi sono diventati sempre più complessi. E' diventato necessario aggiungere *commenti* che descrivessero i comportamenti del codice e il perchè.
+Con il passare del tempo, i programmi sono diventati sempre più complessi. Ed è diventato necessario aggiungere *commenti* per poter descrivere i comportamenti del codice.
 
-I commenti possono essere messi in qualsiasi punto dello script. Infatti non hanno alcun effetto sull'esecuzione del codice, poichè il motore JavaScript semplicemente li ignora.
+I commenti possono essere messi in qualsiasi punto dello script. Infatti non hanno alcun effetto sull'esecuzione del codice, poiché il motore JavaScript semplicemente li ignora.
 
-**I commenti su una singola linea incominciano con due caratteri di slash `//`.**
+**I commenti su una singola linea si inseriscono con due caratteri di slash `//`.**
 
-Il resto della linea è il commento. Può occupare un intera linea oppure seguire l'istruzione.
+Il resto della linea è il commento. Può occupare un intera linea oppure essere posta in seguito ad un'istruzione.
 
-Come segue:
+Vediamo un esempio:
 ```js run
-// Questo commento occupa una riga a parte
+// Questo commento occupa un'intera riga
 alert('Hello');
 
-alert('World'); // Questo commento segue l'istruzione
+alert('World'); // Questo commento segue un istruzione
 ```
 
 **I commenti multilinea incominciano con un singolo carattere di slahs ed un asterisco <code>/&#42;</code> e finiscono con un asterisco ed un carattere di slash <code>&#42;/</code>.**
 
-Come segue:
+Come nell'esempio:
 
 ```js run
 /* Un esempio con due messaggi.
@@ -124,7 +124,7 @@ alert('World');
 
 Il contenuto dei commenti viene ignorato, quindi se inseriamo codice al suo interno <code>/&#42; ... &#42;/</code> non verrà eseguito.
 
-Qualche volta diventa utile per bloccare temporaneamente qualche porzione di codice:
+Qualche volta può essere utile per bloccare temporaneamente qualche porzione di codice:
 ```js run
 /* Commentiamo il codice
 alert('Hello');
@@ -139,7 +139,7 @@ In molti editor una linea di codice può essere commentata con la combinazione d
 ````warn header="I commenti annidati non sono supportati!"
 Non si possono inserire `/*...*/` all'interno di altri `/*...*/`.
 
-Questo codice si bloccherebbe con un errore:
+Questo codice genererebbe un errore:
 
 ```js run no-beautify
 /*