Merge branch 'master' into 014_blur

Author: longo-andrea

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/06-constructor-new/1-two-functions-one-object/solution.md

@@ -1,6 +1,6 @@
 Si, è possibile.
 
-Se una funzione ritorna un oggetto, questo verrà fornito alla `new` piuttosto che `this`.
+Se una funzione ritorna un oggetto, questo verrà ritornato da `new` invece di `this`.
 
 Quindi, le due funzioni potrebbero ritornare un oggetto definito esternamente `obj`:
 

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

@@ -1,12 +1,12 @@
 # Costruttore, operatore "new"
 
-La sintassi `{...}` ci consente di creare un oggetto. Spesso abbiamo bisogno di creare più oggetti simili, come ad esempio più utenti, oggetti del menu e molto altro.
+La sintassi `{...}` ci consente di creare un oggetto. Ma spesso abbiamo bisogno di creare multipli oggetti simili, come ad esempio più utenti, oggetti del menu e molto altro.
 
-Questo può essere fatto utilizzando il costruttore e l'operatore `"new"`.
+Questo può essere fatto utilizzando un costruttore e l'operatore `"new"`.
 
 ## Costruttore
 
-Il costruttore tecnicamente è una normale funzione. Ci sono due convenzioni:
+Tecnicamente un costruttore è una normale funzione. Ma ci sono due convenzioni:
 
 1. Vengono denominati con la prima lettera maiuscola.
 2. Questi dovrebbero essere eseguiti solo con l'operatore `"new"`.
@@ -27,9 +27,9 @@ alert(user.name); // Jack
 alert(user.isAdmin); // false
 ```
 
-Quando una funzione viene eseguita con `new`, segue questi passaggi:
+Quando una funzione viene eseguita con `new`, esegue questi passaggi:
 
-1. Un nuovo oggetto vuoto viene creato ed assegnato a `this`.
+1. Un nuovo oggetto, vuoto, viene creato ed assegnato a `this`.
 2. Viene eseguito il corpo della funzione. Solitamente questo modifica `this`, aggiungendo nuove proprietà.
 3. Viene ritornato il valore assegnato a `this`.
 
@@ -60,11 +60,11 @@ let user = {
 };
 ```
 
-Ora se vogliamo creare altri utenti, possiamo chiamare `new User("Ann")`, `new User("Alice")` e cosi via. Molto più rapido piuttosto che utilizzare oggetti letterali ogni volta, risulta anche più facile da leggere.
+Ora, se vogliamo creare altri utenti, possiamo chiamare `new User("Ann")`, `new User("Alice")` e cosi via. Molto più rapido rispetto all'utilizzare ogni volta oggetti letterali; risulta anche più facile da leggere.
 
-Questo è il principale scopo dei costruttori -- implementare codice riutilizzabile per la creazione degli oggetti.
+Questo è il principale scopo dei costruttori -- implementare codice riutilizzabile per la creazione di oggetti.
 
-Ribadiamo -- tecnicamente, ogni funzione può essere utilizzata come costruttore. Cioè: 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 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:
@@ -80,13 +80,13 @@ let user = new function() {
 };
 ```
 
-Il costruttore non può essere chiamato nuovamente, perché non è salvato da nessuna parte, viene solo creato e chiamato. Quindi questo trucco consente di incapsulare 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 possibilità di riutilizzo futuro.
 ````
 
 ## Costruttori modalità test: new.target
 
 ```smart header="Tecniche avanzate"
-La sintassi presentata in questa sessione viene utilizzata raramente, potete tranquillamente saltarlo se non siete interessati.
+La sintassi presentata nella seguente sezione viene utilizzata raramente; potete tranquillamente saltarla se non vi interessa sapere proprio tutto.
 ```
 
 Dentro la funzione, possiamo controllare quando questa viene chiamata con `new` e quando senza, utilizzando una speciale proprietà `new.target`.
@@ -110,9 +110,9 @@ new User(); // function User { ... }
 */!*
 ```
 
-Questo può essere utilizzato per consentire ad entrambe le chiamate di funzionare (con `new` e senza), quindi sia in in "modalità costruttore" che in "modalità classica".
+Questo può essere utilizzato per consentire ad entrambe le chiamate di funzionare (con `new` e senza), quindi sia in in "modalità costruttore" che in "modalità regolare".
 
-Possiamo anche utilizzarli entrambi `new` e chiamata regole, per fare la stessa cosa, come in questo esempio:
+Possiamo anche fare in modo che le chiamate con *new* e quelle regolari facciano la stessa cosa, come in questo esempio:
 
 ```js run
 function User(name) {
@@ -127,21 +127,21 @@ let john = User("John"); // reindirizza la chiamata a new User
 alert(john.name); // John
 ```
 
-Questo approccio viene adottato in alcune librerie per rendere la sintassi più flessibile. Rendendo possibile la chiamata della funzione sia senza che con la parola chiave`new`.
+Questo approccio viene adottato in alcune librerie per rendere la sintassi più flessibile. Rende possibile la chiamata della funzione sia con `new` che senza.
 
-Non è un ottima cosa utilizzare la doppia sintassi ovunque, perché omettendo `new` il codice perde di leggibilità. Con la parola chiave `new` possiamo dire con certezza che si sta creando un nuovo oggetto.
+Ma non è un'ottima cosa utilizzare la doppia sintassi ovunque, perché omettendo `new` il codice perde in leggibilità. Con la parola chiave `new` possiamo sapere con certezza che si sta creando un nuovo oggetto.
 
 ## Return nel costruttore
 
 
-Solitamente, i costruttori non hanno l'istruzione `return`. Il loro compito è di eseguire tutto ciò che è necessario a creare l'oggetto lavorando su `this`, quest'ultimo sarà il risultato.
+Solitamente, i costruttori non hanno l'istruzione `return`. Il loro compito è di eseguire tutto ciò che è necessario a creare l'oggetto lavorando su `this`; quest'ultimo sarà il risultato.
 
-Se decidiamo di inserire un istruzione di `return`, vanno seguite delle semplici regole:
+Se decidiamo di inserire un'istruzione di `return`, vanno seguite delle semplici regole:
 
 - Se `return` viene invocato con un oggetto, questo verrà ritornato al posto di `this`.
 - Se `return` viene invocato con un tipo primitivo, verrà ignorato.
 
-In altre parole, `return` su un oggetto ritorna quell'oggetto, in tutti gli altri casi verrà ritornato `this`.
+In altre parole, `return` con un oggetto ritorna quell'oggetto; in tutti gli altri casi verrà ritornato `this`.
 
 Ad esempio, qui `return` sovrascrive `this` ritornando un oggetto:
 
@@ -153,7 +153,7 @@ function BigUser() {
   return { name: "Godzilla" };  // <-- ritorna questo oggetto
 }
 
-alert( new BigUser().name );  // Godzilla, ottieni quell'oggetto
+alert( new BigUser().name );  // Godzilla
 ```
 
 Qui invece abbiamo un esempio con un `return` vuoto (potremmo anche ritornare un qualsiasi valore di tipo primitivo):
@@ -163,12 +163,13 @@ function SmallUser() {
 
   this.name = "John";
 
-
-  // ...
-
+  return; // <-- returns this
 }
 
-Solitamente i costruttori non possiedono l'istruzione `return`. Qui per completezza abbiamo citato gli eventuali comportamenti, se si tenta di ritornare un oggetto.
+alert(new SmallUser().name);  //John
+```
+
+Solitamente i costruttori non hanno l'istruzione `return`. Abbiamo comunque riportato, per completezza, quel che succede se si tenta di ritornare un oggetto.
 
 ````smart header="Omettere le parentesi"
 Possiamo anche omettere le parentesi dopo `new`, se non ci sono argomenti:
@@ -184,11 +185,11 @@ L'omissione delle parentesi non viene considerata come "buona programmazione", l
 
 ## Metodi in un costruttore
 
-Utilizzare costruttori per creare degli oggetti fornisce una grande vantaggio in termini di flessibilità. Il costruttore può avere dei parametri che definiscono come costruire l'oggetto, e cosa "metterci dentro".
+Utilizzare costruttori per creare degli oggetti ci dà un grande vantaggio in termini di flessibilità. Il costruttore può avere dei parametri che definiscono come costruire l'oggetto, e cosa "metterci dentro".
 
 Ovviamente, possiamo aggiunger a `this` non solo proprietà, ma anche metodi.
 
-Ad esempio, `new User(name)` crea un oggetto con un nome dato `name` e un metodo `sayHi`:
+Ad esempio, `new User(name)` crea un oggetto con un nome (passato come `name`) e un metodo `sayHi`:
 
 ```js run
 function User(name) {
@@ -202,7 +203,7 @@ function User(name) {
 *!*
 let john = new User("John");
 
-john.sayHi(); // Il mio nome è: John
+john.sayHi(); // My name is: John
 */!*
 
 /*
@@ -217,15 +218,15 @@ Per creare oggetti più complessi, esiste una sintassi più avanzata, [classes](
 
 ## Riepilogo
 
-- Le funzioni di costruzione, o meglio, i costruttori, solo delle normali funzioni, che seguono però una regola di accordo comune che prevede di denominarle con la prima lettera maiuscola.
-- Un costruttore dovrebbe essere chiamato solamente utilizzando `new`. Questo tipo di chiamata implica la creazione di un oggetto vuoto `this`, che verrà popolato entro la fine della funzione.
+- Le funzioni di costruzione, o meglio, i costruttori, sono solo delle normali funzioni; seguono però una convenzione comune che prevede di denominarle con la prima lettera maiuscola.
+- Un costruttore dovrebbe essere chiamato solamente utilizzando `new`. Questo tipo di chiamata implica la creazione di un oggetto vuoto, `this`, che verrà popolato entro la fine della funzione.
 
 Possiamo utilizzare i costruttori per costruire molti oggetti simili tra loro.
 
 JavaScript fornisce costruttori per la maggior parte degli oggetti integrati nel linguaggio: come `Date` per le date, `Set` per gli insiemi e molti altri che studieremo più avanti.
 
 ```smart header="Oggetti, ci ritorneremo!"
-In questo capitolo abbiamo coperto solamente le basi degli oggetti e dei costruttori. Era necessario conoscerne le basi per capire meglio riguardo i data types e le funzioni che studieremo nel prossimo capitolo.
+In questo capitolo abbiamo coperto solamente le basi degli oggetti e dei costruttori. Era necessario conoscerne le basi per capire meglio i data types e le funzioni che studieremo nel prossimo capitolo.
 
-Dopo averli compresi, ritorneremo sugli oggetti e li analizzeremo più in dettaglio nei capitoli <info:prototypes> e <info:classes>.
+Dopo questo, ritorneremo sugli oggetti e li analizzeremo più in dettaglio nei capitoli <info:prototypes> e <info:classes>.
 ```