minor fixes

Author: pasor1

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

@@ -35,15 +35,15 @@ Ed ecco come viene effettivamente archiviata in memoria:
 
 ![](variable-contains-reference.svg)
 
-L'oggetto è archiviato da qualche parte nella memoria (sulla destra dell'immagine), mentre la variabile `user` (sulla sinistra) contiene il "riferimento" ad esso.
+L'oggetto è archiviato da qualche parte nella memoria (a destra nell'immagine), mentre la variabile `user` (a sinistra) contiene il "riferimento" ad esso.
 
 Potremmo immaginare la variabile oggetto `user`,  come un foglio di carta con scritto l'indirizzo dell'oggetto.
 
 Quando eseguiamo azioni con l'oggetto, ad es. leggere una proprietà `user.name`, il motore JavaScript guarda cosa c'è a quell'indirizzo ed esegue l'operazione sull'oggetto reale.
 
 Ecco perché è così importante.
 
-**Quando una variabile oggetto viene copiata, in realtà viene copiato il riferimento, ma l'oggetto in sé non viene duplicato.**
+**Quando una "variabile oggetto" viene copiata, in realtà viene copiato il riferimento, ma l'oggetto in sé non viene duplicato.**
 
 Esempio:
 
@@ -89,7 +89,7 @@ alert( a == b ); // true, entrambe le variabili si riferiscono allo stesso ogget
 alert( a === b ); // true
 ```
 
-Qui, invece, due oggetti identici (entrambi vuoti) ma indipendenti, non soddisfano l'uguaglianza:
+Qui, invece, due oggetti identici (entrambi vuoti), ma indipendenti, non soddisfano l'uguaglianza:
 
 
 ```js run
@@ -107,7 +107,7 @@ Come abbiamo detto, copiare una variabile oggetto crea un ulteriore riferimento
 
 Quindi, come possiamo fare se abbiamo bisogno di duplicare un oggetto? Creare una copia indipendente, un clone?
 
-Anche questo è fattibile, ma con un po' di difficoltà visto che JavaScript non integra alcun metodo per farlo. In realtà non è un'operazione frequente, il più delle volte la copia per riferimento è adatta alla situazione.
+Anche questo è fattibile, ma con un po' di difficoltà visto che JavaScript non ha alcun metodo integrato per farlo. In realtà non è un'operazione frequente, il più delle volte la copia per riferimento è adatta alla situazione.
 
 Ma se proprio ne abbiamo bisogno, allora dobbiamo creare un nuovo oggetto e replicare la struttura di quello esistente iterando le sue proprietà
 e copiandole a livello primitivo.
@@ -123,7 +123,7 @@ let user = {
 *!*
 let clone = {}; // il nuovo oggetto vuoto
 
-// copiamo in clone tutte le proprietà di user
+// copiamo nella variabile clone tutte le proprietà di user
 for (let key in user) {
   clone[key] = user[key];
 }
@@ -144,8 +144,8 @@ Object.assign(dest, [src1, src2, src3...])
 ```
 
 - Il primo argomento `dest` è l'oggetto di destinazione.
-- Gli argomenti successivi `src1, ..., srcN` (possono essere quanti vogliamo) sono gli oggetti sorgente.
-- Il metodo copia tutte le proprietà degli oggetti sorgente `src1, ..., srcN` in quello di destinazione `dest`.
+- Gli argomenti successivi `src1, ..., srcN` (possono essere quanti vogliamo) sono gli oggetti da copiare.
+- Il metodo copia tutte le proprietà degli oggetti `src1, ..., srcN` in quello di destinazione `dest`.
 - Viene restituito l'oggetto `dest`.
 
 Per fare un esempio, possiamo unire diversi oggetti in uno solo:
@@ -187,7 +187,7 @@ let clone = Object.assign({}, user);
 */!*
 ```
 
-Vengono copiate tutte le proprietà di `user` nell'oggetto vuoto, quindi esso viene restituito.
+Vengono copiate tutte le proprietà di `user` nell'oggetto vuoto, il quale, poi, viene restituito.
 
 ## Clonazione nidificata
 
@@ -229,11 +229,11 @@ user.sizes.width++;       // cambiamo una proprietà da una parte
 alert(clone.sizes.width); // 51, e vediamo il risultato dall'altra
 ```
 
-Per correggere questo problema, dobbiamo usare un ciclo di clonazioni che esaminerà ogni valore di `user[key]` e, nel caso sia un oggetto, replichi anche la sua struttura. Questa operazione è chiamata "deep cloning" (copia profonda).
+Per risolvere questo problema, dobbiamo usare un ciclo di clonazioni che esaminerà ogni valore di `user[key]` e, nel caso sia un oggetto, replichi anche la sua struttura. Questa operazione è chiamata "deep cloning" (copia profonda).
 
 Per implementare questa funzione possiamo usare la ricorsione. Oppure, per non reinventare la ruota, possiamo usare qualcosa di già pronto, ad esempio [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) dalla libreria JavaScript [lodash](https://lodash.com).
 
-````smart header="Gli oggetti dichiarati con Const possono essere modificati"
+````smart header="Gli oggetti dichiarati con const possono essere modificati"
 Un importante "side effect" della memorizzazione per riferimento è che un oggetto dichiarato con `const` *può* essere modificato.
 
 Esempio:
@@ -252,7 +252,7 @@ alert(user.name); // Pete
 
 Saremmo portati a pensare che la linea `(*)` causi un errore, ma non è così. Il valore di `user` è costante, si riferisce sempre allo stesso oggetto, ma le proprietà dell'oggetto sono libere di cambiare.
 
-In altre parole, `const user` restituisce un errore solo se se proviamo a riassegnare del tutto `user=...`.
+In altre parole, `const user` restituisce un errore solo se se proviamo a riassegnare in toto `user=...`.
 
 Detto questo, se vogliamo veramente rendere invariabili le proprietà di un oggetto, possiamo farlo, ma con un metodo totalmente differente. Ne parleremo nel capitolo <info:property-descriptors>.
 ````