Merge pull request #249 from Dorin-David/Article/keys-values-entries

review Destructuring assignment

Author: longo-andrea

1-js/05-data-types/10-destructuring-assignment/1-destruct-user/task.md

@@ -17,14 +17,14 @@ Scrivete l'assegnamento di destrutturazione che legge:
 
 - la proprietà `name` nella variabile `name`.
 - la proprietà `years` nella variabile `age`.
-- la proprietà `isAdmin` nella variabile `isAdmin` (falsa se assete)
+- la proprietà `isAdmin` nella variabile `isAdmin` (falsa se assente)
 
 I valori dopo l'assegnazione dovrebbero essere:
 
 ```js
 let user = { name: "John", years: 30 };
 
-// your code to the left side:
+// il tuo codice a sinistra:
 // ... = user
 
 alert( name ); // John

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

@@ -5,9 +5,9 @@ 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, potrebbe non èssere necessario tutto l'oggetto/array, ma solo una parte di esso.
+A volte, quando li passiamo ad una funzione, potrebbe non essere 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 conveniente.
+*L'assegnamento di destrutturazione (Destructuring assignment)* è una speciale sintassi che ci consente di "spacchettare" oggetti o array in 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.
 
@@ -30,7 +30,7 @@ alert(firstName); // John
 alert(surname);  // Smith
 ```
 
-Ora possiamo lavorare con le variabili piuttosto che con i membri dell'array.
+Ora possiamo lavorare con le variabili invece che con gli elementi dell'array.
 
 Risulta utilissima se combinata con `split` o altri metodi che ritornano un array:
 
@@ -44,7 +44,7 @@ Come puoi vedere, la sintassi è semplice. Ci sono però molti dettagli peculiar
 
 
 ````smart header="\"Destrutturazione\" non significa \"distruzione\"."
-Viene chiamato "assegnamento di destrutturazione", perché "destrutturizza" copiando gli elementi all'interno di variabili. Ma l'array in sè non viene modificato.
+Viene chiamato "assegnamento di destrutturazione" perché "destruttura" copiando gli elementi all'interno di variabili. Ma l'array in sé non viene modificato.
 
 E' solo un modo breve per scrivere:
 ```js
@@ -56,7 +56,7 @@ let surname = arr[1];
 
 ````smart header="Ignora gli elementi usando la virgola"
 
-Gli elementi indesiderati dell'array possono anche essere ignorati tramite una virgola aggiuntiva:
+Gli elementi indesiderati dell'array possono essere ignorati tramite una virgola aggiuntiva:
 
 ```js run
 *!*
@@ -67,24 +67,24 @@ let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic
 alert( title ); // Consul
 ```
 
-Nel codice sopra, il secondo elemento viene saltato, il terzo viene assegnato a `title`, il resto dell'array viene ignorato (visto che sono state inserite ulteriori variabili).
+Nel codice sopra, il secondo elemento viene saltato, il terzo viene assegnato a `title`, il resto degli elementi vengono ignorati (visto che per loro non ci sono variabili).
 ````
 
-````smart header="Funziona con qualsiasi itarabile sulla destra"
+````smart header="Funziona con qualsiasi iterabile alla destra"
 
-... In realtà, possiamo utilizzarlo con qualsiasi iterabile, non solamente con array:
+... In realtà, possiamo utilizzarlo con qualsiasi iterabile, non solamente con un array:
 
 ```js
 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 a destra. E' una specie di "zucchero sintattico" per chiamare `for..of` sul valore a destra di `=`, assegnandone i valori.
 ````
 
 ````smart header="Assegna a qualsiasi cosa ci sia dalla parte sinistra"
 
-Possiamo inserire qualsiasi cosa sia "assegnabile" alla sinistra.
+Possiamo inserire qualsiasi cosa "assegnabile" a sinistra.
 
 Ad esempio, la proprietà di un oggetto:
 ```js run
@@ -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 chiave/valore di un oggetto:
+Possiamo utilizzarlo con la destrutturazione per eseguire cicli sulle coppie chiave/valore di un oggetto:
 
 ```js run
 let user = {
@@ -117,7 +117,7 @@ for (let [key, value] of Object.entries(user)) {
 }
 ```
 
-Codice simile usando `Map` è più semplice, visto che è iterabile:
+Un codice simile usando `Map` è più semplice, visto che è iterabile:
 
 
 ```js run
@@ -151,8 +151,8 @@ let admin = "Pete";
 alert(`${guest} ${admin}`); // Pete Jane (scambiati con successo!)
 ```
 
-Nell'esempio creiamo un array temporaneo di due varibili e lo destrutturiamo immediatamente invertendo l'ordine delle variabili.
-Nello stesso modo potemmo scambiare i valori di più di sue variabili.
+Nell'esempio creiamo un array temporaneo con due varibili e lo destrutturiamo immediatamente invertendo l'ordine delle variabili.
+Nello stesso modo potremmo scambiare i valori di più variabili.
 
 
 ### L'operatore rest '...'
@@ -171,23 +171,23 @@ alert(name2); // Caesar
 
 ```
 
-Se vogliamo anche ottenere tutto ciò che segue, possiamo aggiungere un altro parametro che raccoglie "il resto" utilizzando tre punti `" ... "`:
+Se vogliamo ottenere anche tutto ciò che segue, possiamo aggiungere un altro parametro che raccoglie "il resto" utilizzando tre punti `" ... "`:
 
 ```js run
 let [name1, name2, *!*...rest*/!*] = ["Julius", "Caesar", *!*"Consul", "of the Roman Republic"*/!*];
 
 *!*
-// rest è un array di elementi, che parte dal terzo
+// rest è un array con gli elementi a destra, partendo dal terzo
 alert(rest[0]); // Consul
 alert(rest[1]); // of the Roman Republic
 alert(rest.length); // 2
 */!*
 ```
 
 
-La variabile `rest` è un array dei valori dell'array rimanenti.
+La variabile `rest` è un array con i valori rimanenti dell'array a destra.
 
-Possiamo utilizzare qualsiasi altro nome di variabile al posto di `rest`, è sufficiente accertarsi di inserire i tre punti prima del nome e di posizionarlo alla fine nell'assegnamento di destrutturazione.
+Possiamo utilizzare qualsiasi altro nome di variabile al posto di `rest`; è sufficiente accertarsi di inserire i tre punti prima del nome e di posizionarlo alla fine nell'assegnamento di destrutturazione.
 
 ```js run
 let [name1, name2, *!*...titles*/!*] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
@@ -275,10 +275,10 @@ L'ordine non ha importanza. Questo codice funzionerebbe comunque:
 let {height, width, title} = { title: "Menu", height: 200, width: 100 }
 ```
 
-Il pattern alla sinistra potrebbe essere anche più complesso e specificare una mappatura tra proprietà e variabili.
+Il pattern a sinistra potrebbe essere anche più complesso e specificare una mappatura tra proprietà e variabili.
 
 
-Se volessimo assegnare una proprietà ad una variabile con un altro nome, ad esempio, la proprietà `options.width` vogliamo assegnarla ad una variabile chiamata `w`, allora possiamo specificarlo con i due punti:
+Se volessimo assegnare una proprietà ad una variabile con un altro nome, ad esempio la proprietà `options.width` ad una variabile chiamata `w`, allora possiamo specificarlo con i due punti:
 
 
 ```js run
@@ -370,9 +370,9 @@ alert(title); // Menu
 
 ### 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?
+Cosa succede se l'oggetto possiede più proprietà delle variabili da noi fornite? Possiamo prenderne solamente alcune ed assegnare tutto ciò che avanza da un'altra parte?
 
-La specifica per l'utilizzo dell'operatore resto (tre punti) fa quasi parte dello standard, ma molti browser non lo supportano ancora.
+La specifica per l'utilizzo dell'operatore rest `...`  fa quasi parte dello standard, ma molti browser non lo supportano ancora.
 
 Appare cosi:
 
@@ -452,7 +452,7 @@ let {
     width,
     height
   },
-  items: [item1, item2], // assegniamo gli item qui
+  items: [item1, item2], // assegniamo gli items qui
   title = "Menu" // non presente nell'oggetto (viene utilizzato il valore di default)
 } = options;
 
@@ -463,21 +463,13 @@ alert(item1);  // Cake
 alert(item2);  // Donut
 ```
 
-L'intero oggetto `options` ad eccezione di `extra` il quale non viene menzionato, viene assegnato alle corrispondenti variabili.
-
-Nota che `size` e `items` stesso non è destrutturato.
+L'intero oggetto `options` ad eccezione di `extra`, il quale non viene menzionato, viene assegnato alle corrispondenti variabili.
 
 ![](destructuring-complex.svg)
 
-Infine, abbiamo `width`, `height`, `item1`, `item2` e `title` che assumo il valore di default.
-
-Questo accade spesso con l'assegnamento di destrutturazione. Abbiamo un oggetto complesso e vogliamo estrarre solamente ciò di cui abbiamo bisogno.
+Infine, abbiamo `width`, `height`, `item1`, `item2` e `title` che assumono il valore di default.
 
-Anche qui accade lo stesso:
-```js
-// prende size per interno su una variabile, ignora il resto
-let { size } = options;
-```
+Nota che non ci sono variabili per `size` e `items`: prendiamo invece il loro contenuto. Questo accade spesso con l'assegnamento di destrutturazione. Abbiamo un oggetto complesso e vogliamo estrarre solamente ciò di cui abbiamo bisogno.
 
 ## Parametri di funzione intelligenti
 
@@ -491,7 +483,7 @@ function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
 }
 ```
 
-Nella vita reale, il problema è ricordarsi l'ordine degli argomenti. Solitamente gli IDE ci aiutano in questo, specialmente se il codice è ben documentato, ma ancora... Un ulteriore problema è quello di chiamare una funzione nel caso in cui molti parametri ci vadano bene di default.
+Nella vita reale, il problema è ricordarsi l'ordine degli argomenti. Solitamente gli IDE ci aiutano in questo, specialmente se il codice è ben documentato, eppure... Un ulteriore problema è quello di chiamare una funzione nel caso in cui molti parametri ci vadano bene di default.
 
 Come qui?
 
@@ -504,7 +496,7 @@ E' brutto a vedersi. E diventa illeggibile quando il numero di parametri aumenta
 
 La destrutturazione ci viene in soccorso!
 
-Possiamo passare i parametri come un oggetto, e la funzione immediatamente lo destrutturizza in variabili:
+Possiamo passare i parametri come un oggetto, e la funzione immediatamente lo destrutturizzerà in variabili:
 
 ```js run
 // passiamo l'oggetto alla funzione
@@ -513,7 +505,7 @@ let options = {
   items: ["Item1", "Item2"]
 };
 
-// ...e immediatamente lo espandiamo su variabili
+// ...e immediatamente lo distribuisce alle variabili
 function showMenu(*!*{title = "Untitled", width = 200, height = 100, items = []}*/!*) {
   // title, items – presi da options,
   // width, height – valori di default
@@ -556,15 +548,15 @@ function({
 })
 ```
 
-Da notare che la destrutturazione assume che `showMenu()` abbia un argomento. Se vogliamo tutti i valori di default, allora dovremmo specificare un oggetto vuoto:
+Da notare che la destrutturazione presuppone che `showMenu()` abbia un argomento. Se vogliamo tutti i valori di default, allora dovremmo specificare un oggetto vuoto:
 
 ```js
-showMenu({}); // ok, all values are default
+showMenu({}); // ok, tutti i valori sono di default
 
 showMenu(); // questo darà errore
 ```
 
-Possiamo farlo ponendo `{}` il valore di default per l'intera destrutturazione:
+Possiamo farlo ponendo `{}` come valore di default per l'intera destrutturazione:
 
 
 ```js run
@@ -576,17 +568,17 @@ function showMenu(*!*{ title = "Menu", width = 100, height = 200 } = {}*/!*) {
 showMenu(); // Menu 100 200
 ```
 
-Nel codice sopra, tutti gli argomenti dell'oggetto sono `{}` di default, quindi ci sarà sempre qualcosa da destrutturare.
+Nel codice sopra, l'oggetto degli argomenti è `{}` di default, quindi ci sarà sempre qualcosa da destrutturare.
 
 ## Riepilogo
 
-- L'assegnamento di destrutturazione ci consente di mappare un oggetto o un array su alcune variabili.
+- L'assegnamento di destrutturazione ci consente di mappare un oggetto o un array passandolo a variabili.
 - La sintassi per gli oggetti:
     ```js
     let {prop : varName = default, ...rest} = object
     ```
 
-    Questo significa che la proprietà `prop` dovrebbe andare nella variabile `varName` e, se non esiste alcuan proprietà, allora verrà utilizzato il valore di `default`.
+    Questo significa che la proprietà `prop` dovrebbe andare nella variabile `varName` e, se non esiste alcuna proprietà, allora verrà utilizzato il valore di `default`.
 
 - La sintassi per gli array: