Merge pull request #218 from pasor1/sync

Sync

Author: pasor1

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)