Sincronizzazione con versione inglese

1-js/01-getting-started/1-intro/article.md

@@ -26,7 +26,7 @@ Esistono altri motori JavaScript, tra cui:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- per Chrome e Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- per Firefox.
-- ...Ci sono altri codenames come "Chakra" per IE, "ChakraCore" specifico per Microsoft Edge, "Nitro" e "SquirrelFish" per Safari, etc.
+- ...Ci sono altri codenames come "Chakra" per IE, "JavaScriptCore", "Nitro" e "SquirrelFish" per Safari, etc.
 
 I nomi citati sopra possono essere utili da ricordare, poiché si possono trovare spesso in articoli che trattano di sviluppo web. Anche noi li useremo. Ad esempio, se "una caratteristica X è supportata da V8", probabilmente funzioneranno senza problemi in Chrome e Opera.
 

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

@@ -45,7 +45,7 @@ alert(3 +
 + 2);
 ```
 
-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.
+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 sarebbe errato. Per questo, nell'esempio sopra, tutto funziona come dovrebbe.
 
 **Ma ci sono casi in cui JavaScript "fallisce" nell'interpretare un punto e virgola, dove invece sarebbe necessario.**
 
@@ -55,39 +55,38 @@ Gli errori di questo tipo sono molto difficili da trovare e sistemare.
 Se sei curioso di vedere un esempio concreto di questo tipo di errore, dai un occhiata al seguente codice:
 
 ```js run
-[1, 2].forEach(alert)
+alert("Hello");
+
+[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: mostrerà `1` e poi `2`.
 
-Adesso andiamo ad aggiungere un `alert` prima del codice e *non* concludiamo la riga con il punto e virgola:
+Adesso andiamo a rimuovere il punto e virgola dopo `alert`:
 
 ```js run no-beautify
-alert("There will be an error")
+alert("Hello")
 
-[1, 2].forEach(alert)
+[1, 2].forEach(alert);
 ```
 
-Adesso se lo eseguiamo, solo il primo `alert` viene mostrato, poi avremmo un errore!
-
-Ma tutto si risolve aggiungendo un punto e virgola dopo `alert`:
-```js run
-alert("All fine now");
+La differenza rispetto al codice precedente è solo un carattere, il punto e virgola al termine della prima line è sparito.  
 
-[1, 2].forEach(alert)  
-```
+Se eseguiamo il codice, verrà mostrato solo il primo `Hello` (ci sarà un errore, ma per visualizzarlo bisogna aprire la console). Non verranno più mostrati i numeri.
 
-Adesso avremmo il messaggio "All fine now", successivamente `1` seguito da `2`.
+Questo perché JavaScript non inserisce il punto e virgola prima della parentesi quadre `[...]`. Quindi il codice viene interpretato come un singolo comando.
 
-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. Infatti il motore JavaScript lo vede cosi:
+Ecco come il motore interpreta il codice:
 
 ```js run no-beautify
-alert("There will be an error")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert);
 ```
 
-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.
+Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
+
+Sembra strano, vero? Questo comportamento in questo caso è errato. E' necessario mettere un punto e virgola dopo `alert` affinché il codice funzioni correttamente.
+
+Questo accade anche in altre situazioni.
 ````
 
 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.
@@ -110,7 +109,7 @@ alert('Hello');
 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>.**
+**I commenti multilinea incominciano con un singolo carattere di slash ed un asterisco <code>/&#42;</code> e finiscono con un asterisco ed un carattere di slash <code>&#42;/</code>.**
 
 Come nell'esempio:
 

1-js/02-first-steps/05-types/article.md

@@ -64,7 +64,7 @@ I numeri con valore speciale appartengono formalmente al tipo "numerico". Ovviam
 
 Vedremo di più su come lavorare con i numeri nel capitolo <info:number>.
 
-## BigInt
+## BigInt [#bigint-type]
 
 In JavaScript, il tipo "number" non può rappresentare valori interni più grandi di <code>(2<sup>53</sup>-1)</code> (che equivale a `9007199254740991`), o minori di <code>-(2<sup>53</sup>-1)</code>. Questa è una limitazione tecnica dovuta alla loro rappresentazione interna.
 

1-js/02-first-steps/08-operators/article.md

@@ -66,7 +66,7 @@ Ad esempio:
 
 ```js run
 alert( 2 ** 2 ); // 2² = 4
-alert( 2 ** 3 ); // 2³ = 8 
+alert( 2 ** 3 ); // 2³ = 8
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 

1-js/02-first-steps/15-function-basics/article.md

@@ -20,10 +20,10 @@ function showMessage() {
 }
 ```
 
-La parola chiave `function` va posta all'inizio; viene seguita dal *nome della funzione*, poi c'è una lista di *parametri*, racchiusi tra parentesi (in questo esempio la lista è vuota) e infine il codice della funzione, chiamato anche "corpo della funzione", racchiuso tra parentesi graffe.
+La parola chiave `function` va posta all'inizio; viene seguita dal *nome della funzione*, poi c'è una lista di *parametri*, racchiusi tra parentesi (separati da virgola, in questo esempio la lista è vuota, vedremo un esempio più avanti) e infine il codice della funzione, chiamato anche "corpo della funzione", racchiuso tra parentesi graffe.
 
 ```js
-function name(parameters) {
+function name(parameter1, parameter2, ... parameterN) {
   ...body...
 }
 ```
@@ -137,26 +137,23 @@ Solitamente, una funzione dichiara internamente tutte le variabili necessarie pe
 
 ## Parametri
 
-Possiamo passare dei dati arbitrari ad una funzione usando i parametri (chiamati anche *argomenti della funzione*).
+Possiamo passare dei dati arbitrari ad una funzione usando i parametri.
 
 Nell'esempio sotto, la funzione ha due parametri: `from` e `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // argomenti: from, text
+function showMessage(*!*from, text*/!*) { // parametri: from, text
   alert(from + ': ' + text);
 }
 
-*!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
-*/!*
+*!*showMessage('Ann', 'Hello!');*/!* // Ann: Hello! (*)
+*!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
 ```
 
 Quando la funzione viene chiamata nelle righe `(*)` e `(**)`, il valore passato viene copiato nelle variabili locali `from` e `text`, che verranno utilizzate nella chiamata ad `alert`.
 
 Guardiamo un altro esempio: abbiamo una variabile `from` e la passiamo a una funzione. Da notare: la funzione cambia `from`, ma il cambiamento non è visibile all'esterno perché la funzione usa sempre una copia del valore passato:
 
-
 ```js run
 function showMessage(from, text) {
 
@@ -175,6 +172,18 @@ showMessage(from, "Hello"); // *Ann*: Hello
 alert( from ); // Ann
 ```
 
+Quando un valore viene passato come parametro di funzione, vine anche chiamato *argomento*.
+
+In altre parole
+In other words, per chiarire questi termini:
+
+- Un parametro è la variabile elencata tra parentesi nella dichiarazione della funzione (fa parte della dichiarazione).
+- Un argomento è il valore passato alla funzione quando viene chiamata (fa parte della chiamata).
+
+Dichiariamo le funzioni elencando i loro parametri, quindi le chiamiamo passando gli argomenti.
+
+Nell'esempio sopra, si potrebbe dire: "la funzione `showMessage` è dichiarata con due parametri, quindi viene chiamata con due argomenti: `from` and `"Hello"`".
+
 ## Valori di default
 
 Se non viene fornito alcun parametro, questa assume il valore `undefined`.
@@ -185,9 +194,9 @@ Ad esempio, la funzione menzionata sopra `showMessage(from, text)` può essere c
 showMessage("Ann");
 ```
 
-Questo non è un errore. Una chiamata simile mostrerà `"Ann: undefined"`.  Non c'è nessun valore `text`, quindi si assume che `text === undefined`.
+Questo non è un errore. Una chiamata simile mostrerà `"*Ann*: undefined"`. Siccome non viene passato nessun valore per `text`, questo è `undefined`.
 
-Se volessimo utilizzare un `text` di "default", dovremmo specificarlo dopo `=`:
+Possiamo specificare un cosiddetto valore "default" (da usare se l'argomento è omesso) per i parametri nella dichiarazione di funzione, usando `=`:
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -209,19 +218,23 @@ function showMessage(from, text = anotherFunction()) {
 ```
 
 ```smart header="Valutazione dei parametri di default"
-In JavaScript, un parametro di default viene valutato ogni volta che viene chiamata una funzione senza i rispettivi parametri. Nell'esempio sopra, `anotherFunctions()` viene richiamata ogni volta che `someMessage()` viene chiamata senza il parametro `text`.
-```
+In JavaScript, un parametro di default viene valutato ogni volta che viene chiamata una funzione senza i rispettivo argomento. 
+
+Nell'esempio sopra, `anotherFunctions()` non viene chiamata se viene passato il parametro `text`.
 
+Viene invece chiamata ogni volta che il parametro manca.
+```
 
-#Parametri di default alternativi
-In alcuni casi vorremmo assegnare un valore di default a un parametro non nella dichiarazione della funzione, ma dopo, durante la sua esecuzione. (inoltre, le vecchie edizioni di JavaScript non supportavano i parametri di default; quel che segue è un metodo per ovviare ad entrambe le necessità, e che potreste trovare di frequente nei vecchi script).
+A volte ha senso assegnare valori default ai parametri, non nella dichiarazione della funzione, ma in una fase successiva.
 
-Per controllare se un parametro è stato omesso possiamo compararlo con `undefined`:
+Possiamo verificare se il parametro viene passato durante l'esecuzione della funzione, confrontandolo con `undefined`:
 
 ```js run
 function showMessage(text) {
+  // ...
+
 *!*
-  if (text === undefined) {
+  if (text === undefined) { // if the parameter is missing
     text = 'empty message';
   }
 */!*
@@ -242,11 +255,12 @@ function showMessage(from, text) {
 }
 ```
 
-I moderni motori JavaScript supportano il [nullish coalescing operator](info:nullish-coalescing-operator) `??`, più efficiente quando valori falsi come `0`vengono considerati regolari:
+I moderni motori JavaScript supportano il [nullish coalescing operator](info:nullish-coalescing-operator) `??`, più efficiente quando valori falsi come `0` vengono considerati regolari:
 
 ```js run
 //se non c'è un parametro "count", mostra "unknown"
 function showCount(count) {
+  // if count is undefined or null, show "unknown"
   alert(count ?? "unknown");
 }
 

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -1,4 +1,4 @@
-# Debugging in Chrome
+# Debugging in the browser
 
 Prima di scrivere codice più complesso, dovremmo parlare di debugging.
 

1-js/04-object-basics/06-constructor-new/article.md

@@ -64,13 +64,14 @@ Ora, se vogliamo creare altri utenti, possiamo chiamare `new User("Ann")`, `new
 
 Questo è il principale scopo dei costruttori -- implementare codice riutilizzabile per la creazione di oggetti.
 
-Ribadiamo -- tecnicamente, ogni funzione può essere utilizzata come costruttore. Ovvero: ogni funzione può essere eseguita con `new`. La "prima lettera maiuscola" è semplicemente una convenzione, per rendere esplicito che la funzione deve essere eseguita con `new`.
+Ribadiamo -- tecnicamente, ogni funzione (eccetto le arrow functions, siccome non hanno `this`) può essere utilizzata come costruttore. Ovvero: ogni funzione può essere eseguita con `new`. La "prima lettera maiuscola" è semplicemente una convenzione, per rendere esplicito che la funzione deve essere eseguita con `new`.
 
 ````smart header="new function() { ... }"
-Se abbiamo molte linee di codice utili alla creazione di un unico oggetto, possiamo raggrupparle in un costruttore, come qui:
+Se abbiamo molte linee di codice utili alla creazione di un unico oggetto, possiamo raggrupparle in un costruttore richiamato contestualmente, come qui:
 
 ```js
-let user = new function() {
+// create a function and immediately call it with new
+let user = new function() { 
   this.name = "John";
   this.isAdmin = false;
 
@@ -80,7 +81,7 @@ let user = new function() {
 };
 ```
 
-Il costruttore non può essere chiamato nuovamente, perché non è salvato da nessuna parte; viene solo creato e chiamato. Questo trucco consente di incapsulare un codice che costruisce un singolo oggetto, senza possibilità di riutilizzo futuro.
+Il costruttore non può essere chiamato nuovamente, perché non è salvato da nessuna parte; viene solo creato e chiamato. Questo trucco consente di incapsulare un codice che costruisce un singolo oggetto, senza necessità di riutilizzo futuro.
 ````
 
 ## Costruttori modalità test: new.target