Sync

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -9,7 +9,6 @@ true + false = 1
 "$" + 4 + 5 = "$45"
 "4" - 2 = 2
 "4px" - 2 = NaN
-7 / 0 = Infinity
 "  -9  " + 5 = "  -9  5" // (3)
 "  -9  " - 5 = -14 // (4)
 null + 1 = 1 // (5)

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md

@@ -16,7 +16,6 @@ true + false
 "$" + 4 + 5
 "4" - 2
 "4px" - 2
-7 / 0
 "  -9  " + 5
 "  -9  " - 5
 null + 1

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

@@ -1,6 +1,6 @@
 # Operatori logici
 
-In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), e `!` (NOT).
+In JavaScript ci sono quattro operatori logici: `||` (OR), `&&` (AND), e `!` (NOT), `??` (Nullish Coalescing). Qui abbiamo trattato i primi tre, l'operatore `??` sarà approfondito nel prossimo articolo. 
 
 Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani (i risultati stessi possono essere di qualunque tipo).
 
@@ -103,7 +103,7 @@ Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR
 
     Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutte opzionali (possono quindi essere *undefined* o avere valori falsi).
 
-    Possiamo utilizzare OR `||` per selezionare quella che contiene un valore e mostrarlo (oppure mostrare `"Anonymous"` se nessua variabile è definita):
+    Possiamo utilizzare OR `||` per selezionare quella che contiene un valore e mostrarlo (oppure mostrare `"Anonymous"` se nessuna variabile è definita):
 
     ```js run
     let firstName = "";
@@ -139,7 +139,7 @@ L'operatore AND viene rappresentato con `&&`:
 result = a && b;
 ```
 
-Nella programmazione classica AND ritorna `true` se entrambri gli operandi sono veri, altrimenti ritorna `false`:
+Nella programmazione classica AND ritorna `true` se entrambi gli operandi sono veri, altrimenti ritorna `false`:
 
 ```js run
 alert( true && true );   // true
@@ -219,7 +219,7 @@ Quindi il codice `a && b || c && d` è analogo all'espressione: `(a && b) || (c
 ````
 
 ````warn header="Non rimpiazzate `if` con `||` o `&&`"
-Talvolta, le persone utilizzano l'operatore AND `&&` come una "scorcatoia" dell'espressione `if`".
+Talvolta, le persone utilizzano l'operatore AND `&&` come una "scorciatoia" dell'espressione `if`".
 Proprio come l'OR, anche AND `&&` può qualche volta rimpiazzare `if`.
 
 Ad esempio:
@@ -232,7 +232,7 @@ let x = 1;
 
 Le azioni nella parte destra di `&&` vengono eseguite solamente se la valutazione non si ferma prima. Cioè: solo se `(x > 0)` è vera.
 
-Il codie sopra è sostanzialmente analogo a:
+Il codice sopra è sostanzialmente analogo a:
 
 ```js run
 let x = 1;

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -4,12 +4,12 @@
 
 Il *nullish coalescing operator* è rappresentato da due punti di domanda `??`.
 
+Siccome trattiamo `null` e `undefined` in modo simile, avremo bisogno di una definizione particolare. In questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.
+
 Il risultato di `a ?? b` è:
 - se `a` è definito, allora `a`,
 - se `a` non è definito, allora `b`.
 
-(In questo articolo, diremo che un'espressione è "definita" quando non è né `null` né `undefined`.)
-
 In altre parole, tra due operatori `??` ritorna il primo se questo non è `null/undefined`; altrimenti, ritorna il secondo.
 
 Il nullish coalescing operator non è qualcosa di completamente nuovo. È solo un modo più elegante per recuperare il primo valore "definito" tra due operatori.
@@ -27,15 +27,15 @@ Per esempio, qui mostriamo `Anonymous` se `user` non è definito:
 ```js run
 let user;
 
-alert(user ?? "Anonymous"); // Anonymous
+alert(user ?? "Anonymous"); // Anonymous (user not defined)
 ```
 
 Ovviamente, se `user` ha un qualsiasi valore eccetto `null/undefined`, allora vedremo quel valore:
 
 ```js run
 let user = "John";
 
-alert(user ?? "Anonymous"); // John
+alert(user ?? "Anonymous"); // John (user defined)
 ```
 
 Possiamo anche usare una sequenza di `??` per selezionare, da una lista, il primo valore che non sia `null/undefined`.

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -5,15 +5,15 @@ Esiste un'altra sintassi molto semplice e concisa per creare funzioni e che spes
 E' chiamata "arrow functions", perché si presenta in questo modo:
 
 ```js
-let func = (arg1, arg2, ...argN) => expression
+let func = (arg1, arg2, ..., argN) => expression
 ```
 
 Questo codice crea una funzione `func` che accetta gli argomenti `arg1..argN` e li utilizza per valutare `expression` e restituirne il risultato.
 
 In altre parole è una versione abbreviata di:
 
 ```js
-let func = function(arg1, arg2, ...argN) {
+let func = function(arg1, arg2, ..., argN) {
   return expression;
 };
 ```

1-js/04-object-basics/02-object-copy/article.md

@@ -189,6 +189,7 @@ let clone = Object.assign({}, user);
 
 Vengono copiate tutte le proprietà di `user` nell'oggetto vuoto, il quale, poi, viene restituito.
 
+Esistono anche altri modi per clonare un oggetto, ad esempio usando lo [spread operator](info:rest-parameters-spread) `clone = {...user}`, che verrà trattato più avanti in questo tutorial.
 ## Clonazione nidificata
 
 Finora abbiamo assunto che le proprietà di `user` fossero primitive. Ma le proprietà possono anche essere riferimenti ad altri oggetti. Come si fa in questo caso? 

1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md

@@ -21,7 +21,7 @@ let ladder = {
     return this;
 */!*
   }
-}
+};
 
 ladder.up().up().down().up().down().showStep(); // 1
 ```

1-js/04-object-basics/07-optional-chaining/article.md

@@ -25,14 +25,14 @@ Questo è il risultato che ci si aspetta. JavaScript funziona in questo modo. Se
 
 Nella maggior parte dei casi, preferiremmo avere `undefined` piuttosto di un errore (in questo caso con il significato "nessuna via").
 
-... Un altro esempio. Il metodo `document.querySelector('.elem')` ritorna un oggetto che corrisponde ad un elemento della pagina web, che ritorna `null` quando l'elemento non esite.
+... Un altro esempio. Il metodo `document.querySelector('.elem')` ritorna un oggetto che corrisponde ad un elemento della pagina web, che ritorna `null` quando l'elemento non esiste.
 
 ```js run
 // document.querySelector('.elem') è null se non esiste l'elemento
 let html = document.querySelector('.elem').innerHTML; // errore se è null
 ```
 
-Di nuovo, se un elemente non esiste, otterremo un errore nel tentativo di accedere a `.innerHTML` di `null`. In alcuni casi, in cui l'assenza di un elemento è normale, vorremo evitare l'errore e accettare come risultato `html = null`.
+Di nuovo, se un elemento non esiste, otterremo un errore nel tentativo di accedere a `.innerHTML` di `null`. In alcuni casi, in cui l'assenza di un elemento è normale, vorremo evitare l'errore e accettare come risultato `html = null`.
 
 Come possiamo farlo?
 
@@ -63,7 +63,7 @@ Ci sarebbe un modo migliore per riscriverlo, utilizzando l'operatore `&&`:
 ```js run
 let user = {}; // l'utente non ha address
 
-alert( user.address && user.address.street && user.address.street.name ); // undefined (nessune errore)
+alert( user.address && user.address.street && user.address.street.name ); // undefined (nessun errore)
 ```
 
 Concatenare con `&&` l'intero percorso verso la proprietà ci assicura che tutti i componenti esistano (in caso contrario, la valutazione si interrompe), ma non è comunque l'ideale.

1-js/05-data-types/10-destructuring-assignment/6-max-salary/_js.view/solution.js

@@ -4,7 +4,7 @@ function topSalary(salaries) {
   let maxName = null;
 
   for(const [name, salary] of Object.entries(salaries)) {
-    if (max < salary) {
+    if (maxSalary < salary) {
       maxSalary = salary;
       maxName = name;
     }

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -1,13 +1,13 @@
 # Assegnamento di destrutturazione
 
-Le due strutture dati più utilizzate in JavaScritp sono `Object` e `Array`.
+Le due strutture dati più utilizzate in JavaScript sono `Object` e `Array`.
 
 - Gli oggetti ci consentono di creare un'unica entità che memorizza elementi nel formato chiave-valore
 - Gli array ci consentono di raccogliere elementi in elenchi ordinati.
 
-A volte, quando li passiamo ad una funzione, potebbe non èssere necessario tutto l'oggetto/array, ma solo una parte di esso.
+A volte, quando li passiamo ad una funzione, potrebbe non èssere necessario tutto l'oggetto/array, ma solo una parte di esso.
 
-*L'assegnamento di destrutturazione (Destructuring assignment)* è una speciale sintassi che ci consente di "spacchettare" oggetti o array in un gruppi di variabili, questo a volte risulta molto convenente.
+*L'assegnamento di destrutturazione (Destructuring assignment)* è una speciale sintassi che ci consente di "spacchettare" oggetti o array in un gruppi di variabili, questo a volte risulta molto conveniente.
 
 La destrutturazione funziona alla grande anche con funzioni complesse che hanno molti parametri, valori predefiniti e così via. Presto lo vedremo.
 
@@ -79,7 +79,7 @@ let [a, b, c] = "abc"; // ["a", "b", "c"]
 let [one, two, three] = new Set([1, 2, 3]);
 ```
 
-Funziona, perchè internamente un'assegnazione di destrutturazione lavora iterando sul valore di destra. E' una specie di "zucchero sintattico" per chiamare `for..of` sul valore a destra di `=` assegnando i valori.
+Funziona, perché internamente un'assegnazione di destrutturazione lavora iterando sul valore di destra. E' una specie di "zucchero sintattico" per chiamare `for..of` sul valore a destra di `=` assegnando i valori.
 ````
 
 ````smart header="Assegna a qualsiasi cosa ci sia dalla parte sinistra"
@@ -101,7 +101,7 @@ alert(user.surname); // Smith
 
 Nel capitolo precedente abbiamo visto il metodo [Object.entries(obj)](mdn:js/Object/entries).
 
-Possiamo utilizzarlo con la destrutturazione per eseguire cicli su chaivi/valore di un oggetto:
+Possiamo utilizzarlo con la destrutturazione per eseguire cicli su chiave/valore di un oggetto:
 
 ```js run
 let user = {
@@ -135,7 +135,7 @@ for (let [key, value] of user) {
 ````
 
 
-```smart header="Il trucco dello scambio di varibili"
+```smart header="Il trucco dello scambio di variabili"
 c'è un trucco molto conosciuto per scambiare i valori di due variabili usando l'assegnamento di destrutturazione:
 
 
@@ -233,7 +233,7 @@ alert(name);    // Julius (dall'array)
 alert(surname); // qualsiasi cosa provenga dal prompt
 ```
 
-Attenzione: la funzione `prompt` verrà eseguita solo per il valore vancante (`surname`).
+Attenzione: la funzione `prompt` verrà eseguita solo per il valore mancante (`surname`).
 
 ## Destrutturazione di oggetti
 
@@ -322,7 +322,7 @@ alert(height); // 200
 
 Proprio come nel caso degli array o dei parametri di funzione, i valori di default possono essere espressioni più complesse o chiamate a funzioni. Questi verranno valutati solo nel caso in cui il valore non verrà fornito.
 
-Il codice richiederà tramite `prompt` la `width` (larghezzza), ma non il `title` (titolo):
+Il codice richiederà tramite `prompt` la `width` (larghezza), ma non il `title` (titolo):
 
 ```js run
 let options = {
@@ -368,7 +368,7 @@ let { title } = options;
 alert(title); // Menu
 ```
 
-### Il modelo rest "..."
+### Il modello rest "..."
 
 Cosa succede se l'oggetto possiede più proprietà delle variabili da noi fornite? Possiamo prendere solamente alcune ed assegnare tutto ciò che avanza da un'altra parte?
 
@@ -465,7 +465,7 @@ alert(item2);  // Donut
 
 L'intero oggetto `options` ad eccezione di `extra` il quale non viene menzionato, viene assegnato alle corrispondenti variabili.
 
-Note that `size` and `items` itself is not destructured.
+Nota che `size` e `items` stesso non è destrutturato.
 
 ![](destructuring-complex.svg)
 

1-js/06-advanced-functions/02-rest-parameters-spread/article.md

@@ -45,7 +45,7 @@ alert( sumAll(1, 2, 3) ); // 6
 
 Possiamo anche decidere di prendere i primi parametri e memorizzarli in variabili, e i parametri avanzati metterli in un array.
 
-In questo caso i primi due argomenti vengono memorizzati in variabli i restanti finiscono nell'array `titles`:
+In questo caso i primi due argomenti vengono memorizzati in variabili i restanti finiscono nell'array `titles`:
 
 ```js run
 function showName(firstName, lastName, ...titles) {
@@ -225,16 +225,18 @@ C'è però una sottile differenza tra `Array.from(obj)` e `[...obj]`:
 Quindi, per convertire qualcosa in array, la scelta migliore è `Array.from`.
 
 
-## Ottenere una nuova copia di un array/oggetto
+## Copiare un array/oggetto
 
 Ricordate quando abbiamo parlato del metodo [`Object.assign()`](info:object-copy#cloning-and-merging-object-assign)?
 
 E' possibile fare la stessa cosa con l'operatore di espansione (spread).
 
 ```js run
 let arr = [1, 2, 3];
+*!*
 let arrCopy = [...arr]; // espande l'array in una lista di parametri
                         // successivamente inserisce il risultato in un nuovo array
+*/!*
 
 // l'array ha gli stessi contenuti?
 alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
@@ -252,8 +254,10 @@ Da notare che è possibile fare la stessa cosa per copiare un oggetto:
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
+*!*
 let objCopy = { ...obj }; // espande l'oggetto in una lista di parametri
                           // successivamente inserisce il risultato in un oggetto
+*/!*
 
 // l'oggetto ha gli stessi contenuti?
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true

1-js/06-advanced-functions/05-global-object/article.md

@@ -16,7 +16,7 @@ alert("Hello");
 window.alert("Hello");
 ```
 
-In un browserm le variabili globalo dichiarate con `var` diventano proprietà dell'oggetto globale:
+In un browser le variabili globali dichiarate con `var` diventano proprietà dell'oggetto globale:
 
 ```js run untrusted refresh
 var gVar = 5;
@@ -52,7 +52,7 @@ alert(currentUser.name);  // John
 alert(window.currentUser.name); // John
 ```
 
-Detto ciò, l'utilizzo di variabili globali è da evitare. Dovrebbero esserci sempre il minor numero di varibili globali possibili. Il design del codice in cui una funzione richiede un `input` e ritorna un `output` risulta essere molto più chiaro, e molto meno propenso ad errori.
+Detto ciò, l'utilizzo di variabili globali è da evitare. Dovrebbero esserci sempre il minor numero di variabili globali possibili. Il design del codice in cui una funzione richiede un `input` e ritorna un `output` risulta essere molto più chiaro, e molto meno propenso ad errori.
 
 ## Utilizzo di polyfill
 

1-js/06-advanced-functions/12-arrow-functions/article.md

@@ -52,7 +52,7 @@ let group = {
 *!*
     this.students.forEach(function(student) {
       // Error: Cannot read property 'title' of undefined
-      alert(this.title + ': ' + student)
+      alert(this.title + ': ' + student);
     });
 */!*
   }
@@ -87,7 +87,7 @@ For instance, `defer(f, ms)` gets a function and returns a wrapper around it tha
 ```js run
 function defer(f, ms) {
   return function() {
-    setTimeout(() => f.apply(this, arguments), ms)
+    setTimeout(() => f.apply(this, arguments), ms);
   };
 }
 

1-js/11-async/02-promise-basics/article.md

@@ -4,7 +4,7 @@ Immagina di essere un cantante famoso, ed i fan ti chiedono giorno e notte del t
 
 Per avere un pò di sollievo, prometti di inviarglielo quando sarà pubblicato. Fornisci ai tuoi fan una lista. Loro possono compilarla con la loro email, quindi quando la funzione sarà disponibile, tutti gli iscritti la riceveranno. E anche se qualcosa dovesse andare storto, ad esempio un incendio nello studio, che ti impedisce di pubblicare la canzone, i fan verranno comunque notificati.
 
-Tutti sono felici: tu, perchè le persone non ti disturbano più, ed i fan, poichè in questo modo non si perderanno nessuna canzone.
+Tutti sono felici: tu, perché le persone non ti disturbano più, ed i fan, poiché in questo modo non si perderanno nessuna canzone.
 
 1. Un "codice produttore" (producing code) che fa qualcosa e che richiede tempo. Per esempio, il codice che carica uno script remoto. Questo è un "cantante".
 2. Un "codice consumatore" (consuming code) che vuole il risultato del "codice produttore" una volta che è pronto. Molte funzioni possono aver bisogno di questo risultato. Queste sono i "fan".
@@ -146,7 +146,7 @@ promise.then(
 
 Il primo argomento di `.then` è una funzione che esegue quando una promise viene risolta, e ne riceve il risultato.
 
-Il secondo argomento di `.then` è una funzione che esegue quando una promise viene rifiutatam e riceve l'errore.
+Il secondo argomento di `.then` è una funzione che esegue quando una promise viene rifiutata e riceve l'errore.
 
 Per esempio, ecco una reazione ad una promise soddisfatta:
 

1-js/13-modules/02-import-export/article.md

@@ -337,13 +337,19 @@ auth/
         ...
 ```
 
-We'd like to expose the package functionality via a single entry point, the "main file" `auth/index.js`, to be used like this:
+We'd like to expose the package functionality via a single entry point.
+
+In other words, a person who would like to use our package, should import only from the "main file" `auth/index.js`.
+
+Like this:
 
 ```js
 import {login, logout} from 'auth/index.js'
 ```
 
-The idea is that outsiders, developers who use our package, should not meddle with its internal structure, search for files inside our package folder. We export only what's necessary in `auth/index.js` and keep the rest hidden from prying eyes.
+The "main file", `auth/index.js` exports all the functionality that we'd like to provide in our package.
+
+The idea is that outsiders, other programmers who use our package, should not meddle with its internal structure, search for files inside our package folder. We export only what's necessary in `auth/index.js` and keep the rest hidden from prying eyes.
 
 As the actual exported functionality is scattered among the package, we can import it into `auth/index.js` and export from it:
 
@@ -366,14 +372,16 @@ The syntax `export ... from ...` is just a shorter notation for such import-expo
 
 ```js
 // 📁 auth/index.js
-// import login/logout and immediately export them
+// re-export login/logout 
 export {login, logout} from './helpers.js';
 
-// import default as User and export it
+// re-export the default export as User
 export {default as User} from './user.js';
 ...
 ```
 
+The notable difference of `export ... from` compared to `import/export` is that re-exported modules aren't available in the current file. So inside the above example of `auth/index.js` we can't use re-exported `login/logout` functions. 
+
 ### Re-exporting the default export
 
 The default export needs separate handling when re-exporting.

2-ui/1-document/07-modifying-document/1-createtextnode-vs-innerhtml/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 We have an empty DOM element `elem` and a string `text`.
 
-Which of these 3 commands do exactly the same?
+Which of these 3 commands will do exactly the same?
 
 1. `elem.append(document.createTextNode(text))`
 2. `elem.innerHTML = text`