Update article.md

Author: pasor1

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

@@ -2,37 +2,22 @@
 
 Le due strutture dati più utilizzate in JavaScritp sono `Object` e `Array`.
 
-<<<<<<< HEAD
-Gli oggetti ci consentono di raccogliere molti pezzi di informazione in una singola entità, mentre gli array ci consentono di memorizzare collezioni ordinate. Possiamo quindi costruire un oggetto o un array e gestirlo come singola entità, oppure passarlo ad una funzione.
-
-*L'assegnamento di destrutturazione* è una speciale sintassi che ci consente di "spacchettare" oggetti o array in un insieme di variabili, che in molti casi possono risultare più comode. 
-La destrutturazione inoltre funziona molto bene con le funzione complesse che richiedono molti parametri, valori di default, molto presto vedremo come gestire anche questi.
-
-## Destrutturazione di un 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.
 
-Un esempio di come un array viene destrutturato in variabili:
+A volte, quando li passiamo ad una funzione, potebbe non èssere necessario tutto l'oggetto/array, ma solo una parte di esso.
 
-```js
-// abbiamo un array con nome e cognome
-let arr = ["Ilya", "Kantor"]
-=======
-- Objects allow us to create a single entity that stores data items by key. 
-- Arrays allow us to gather data items into an ordered list.
+*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.
 
-Although, when we pass those to a function, it may need not an object/array as a whole. It may need individual pieces.
+La destrutturazione funziona alla grande anche con funzioni complesse che hanno molti parametri, valori predefiniti e così via. Presto lo vedremo.
 
-*Destructuring assignment* is a special syntax that allows us to "unpack" arrays or objects into a bunch of variables, as sometimes that's more convenient. 
-
-Destructuring also works great with complex functions that have a lot of parameters, default values, and so on. Soon we'll see that.
-
-## Array destructuring
+## Destrutturazione di un array
 
-Here's an example of how an array is destructured into variables:
+Ecco un esempio di come un array viene destrutturato in variabili:
 
 ```js
-// we have an array with the name and surname
+// abbiamo un array con nome e cognome
 let arr = ["John", "Smith"]
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 *!*
 // assegnamento di destrutturazione
@@ -47,23 +32,19 @@ alert(surname);  // Smith
 
 Ora possiamo lavorare con le variabili piuttosto che con i membri dell'array.
 
-Risulta utile se combinata con `split` o altri metodi che ritorna un array:
+Risulta utilissima se combinata con `split` o altri metodi che ritornano un array:
 
 ```js run
 let [firstName, surname] = "John Smith".split(' ');
 alert(firstName); // John
 alert(surname);  // Smith
 ```
 
-<<<<<<< HEAD
-````smart header="\"Destrutturazione\" non significa \"distruzione\"."
-Viene chiamato "assegnamento di destrutturazione", perché "destrutturizza" copiando gli elementi all'interno di variabili. Ma l'array stesso non viene modificato.
-=======
-As you can see, the syntax is simple. There are several peculiar details though. Let's see more examples, to better understand it.
+Come puoi vedere, la sintassi è semplice. Ci sono però molti dettagli peculiari. Vediamo altri esempi, per capirlo meglio.
+
 
-````smart header="\"Destructuring\" does not mean \"destructive\"."
-It's called "destructuring assignment," because it "destructurizes" by copying items into variables. But the array itself is not modified.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+````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.
 
 E' solo un modo breve per scrivere:
 ```js
@@ -73,8 +54,9 @@ let surname = arr[1];
 ```
 ````
 
-````smart header="Ignora gli elementi con la virgola"
-Possono essere ignorati degli elementi dell'array inserendo una virgola:
+````smart header="Ignora gli elementi usando la virgola"
+
+Gli elementi indesiderati dell'array possono anche essere ignorati tramite una virgola aggiuntiva:
 
 ```js run
 *!*
@@ -85,29 +67,24 @@ let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic
 alert( title ); // Consul
 ```
 
-Nel codice sopra, il secondo elemento viene ignorato, il terzo viene assegnato a `title`, il resto dell'array viene ignorato.
+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).
 ````
 
-````smart header="Funziona con qualsiasi itarabile"
+````smart header="Funziona con qualsiasi itarabile sulla destra"
 
 ... In realtà, possiamo utilizzarlo con qualsiasi iterabile, non solamente con array:
 
 ```js
 let [a, b, c] = "abc"; // ["a", "b", "c"]
 let [one, two, three] = new Set([1, 2, 3]);
 ```
-That works, because internally a destructuring assignment works by iterating over the right value. It's kind of syntax sugar for calling `for..of` over the value to the right of `=` and assigning the values.
-````
 
+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.
+````
 
-<<<<<<< HEAD
 ````smart header="Assegna a qualsiasi cosa ci sia dalla parte sinistra"
 
 Possiamo inserire qualsiasi cosa sia "assegnabile" alla sinistra.
-=======
-````smart header="Assign to anything at the left-side"
-We can use any "assignables" at the left side.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 Ad esempio, la proprietà di un oggetto:
 ```js run
@@ -120,14 +97,9 @@ alert(user.surname); // Smith
 
 ````
 
-<<<<<<< HEAD
-````smart header="Cicla con .entries()"
+````smart header="Eseguire cicli con .entries()"
 
 Nel capitolo precedente abbiamo visto il metodo [Object.entries(obj)](mdn:js/Object/entries).
-=======
-````smart header="Looping with .entries()"
-In the previous chapter we saw the [Object.entries(obj)](mdn:js/Object/entries) method.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 Possiamo utilizzarlo con la destrutturazione per eseguire cicli su chaivi/valore di un oggetto:
 
@@ -137,123 +109,92 @@ let user = {
   age: 30
 };
 
-// ciclo su chiavi e valori
+// ciclo su chiavi/valori
 *!*
 for (let [key, value] of Object.entries(user)) {
 */!*
   alert(`${key}:${value}`); // name:John, poi age:30
 }
 ```
 
-<<<<<<< HEAD
-...Lo stesso vale per map:
-=======
-The similar code for a `Map` is simpler, as it's iterable:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+Codice simile usando `Map` è più semplice, visto che è iterabile:
+
 
 ```js run
 let user = new Map();
 user.set("name", "John");
 user.set("age", "30");
 
 *!*
-// Map iterates as [key, value] pairs, very convenient for destructuring
+// Map itera le coppie [key, value], molto comodo per la destrutturazione
 for (let [key, value] of user) {
 */!*
   alert(`${key}:${value}`); // name:John, then age:30
 }
 ```
 ````
 
-<<<<<<< HEAD
+
 ```smart header="Il trucco dello scambio di varibili"
-Un metodo molto conosciuto per lo scambio dei valori di due variabili:
-=======
-````smart header="Swap variables trick"
-There's a well-known trick for swapping values of two variables using a destructuring assignment:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+c'è un trucco molto conosciuto per scambiare i valori di due variabili usando l'assegnamento di destrutturazione:
+
 
 ```js run
 let guest = "Jane";
 let admin = "Pete";
 
-<<<<<<< HEAD
 // Scambio dei valori: rende guest=Pete, admin=Jane
-=======
-// Let's swap the values: make guest=Pete, admin=Jane
 *!*
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 [guest, admin] = [admin, guest];
 */!*
 
 alert(`${guest} ${admin}`); // Pete Jane (scambiati con successo!)
 ```
 
-Qui creiamo un array temporaneo di due varibili e lo destrutturiamo immediatamente invertendo l'ordine delle variabili.
-
-<<<<<<< HEAD
-In questo modo possiamo invertire l'ordine di più di due variabili.
+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.
 
-=======
-We can swap more than two variables this way.
-````
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
-### L'operatore resto '...'
+### L'operatore rest '...'
 
-<<<<<<< HEAD
-Se invece vogliamo destrutturare tutto, non solamente il primo elemento, ma raccogliere anche quello che segue -- passiamo un ulteriore parametro nella forma `"..."`:
-=======
-Usually, if the array is longer when the list at the left, the "extra" items are omitted.
+Di solito, se l'array è più lungo della lista a sinistra, gli elementi in eccesso vengono ignorati.
 
-For example, here only two items are taken, and the rest is just ignored:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+Ad esempio, qui vengono presi solo i primi 2 elementi, i restanti vengono semplicemente ignorati:
 
 ```js run
 let [name1, name2] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
 
 alert(name1); // Julius
 alert(name2); // Caesar
-// Furher items aren't assigned anywhere
+// Gli elementi successivi non vengono assegnati
 ```
 
-If we'd like also to gather all that follows -- we can add one more parameter that gets "the rest" using three dots `"..."`:
+Se vogliamo anche ottenere 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"*/!*];
 
 *!*
-<<<<<<< HEAD
-// Da notare che il tipo di `rest` è Array.
-=======
-// rest is array of items, starting from the 3rd one
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+// rest è un array di elementi, che parte dal terzo
 alert(rest[0]); // Consul
 alert(rest[1]); // of the Roman Republic
 alert(rest.length); // 2
 */!*
 ```
 
-<<<<<<< HEAD
-La variabile `rest` è un array dei valori dell'array rimanenti. Possiamo utilizzare qualsiasi altro nome di variabile al posto di `rest`, è sufficiente accertarsi di inserire i tre punti prima del nome.
-=======
-The value of `rest` is the array of the remaining array elements. 
 
-We can use any other variable name in place of `rest`, just make sure it has three dots before it and goes last in the destructuring assignment.
+La variabile `rest` è un array dei valori dell'array rimanenti.
+
+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"];
 // now titles = ["Consul", "of the Roman Republic"]
 ```
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 ### Valori di default
 
-<<<<<<< HEAD
-Se ci sono meno valori nell'array delle variabili da assegnare, non ci sarà alcun errore. I valori assenti vengono considerati undefined:
-=======
-If the array is shorter than the list of variables at the left, there'll be no errors. Absent values are considered undefined:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+Se ci sono meno elementi nell'array delle variabili da assegnare, non ci sarà alcun errore. I valori assenti vengono considerati undefined:
 
 ```js run
 *!*
@@ -264,7 +205,7 @@ alert(firstName); // undefined
 alert(surname); // undefined
 ```
 
-Se volessimo utilizzare un nostro valore di "default", potremmo fornirlo con la sintassi `=`:
+Se volessimo assegnare un nostro valore di "default", potremmo indicarlo con la sintassi `=`:
 
 ```js run
 *!*
@@ -276,13 +217,11 @@ alert(name);    // Julius (dall'array)
 alert(surname); // Anonymous (valore di default)
 ```
 
-I valori di default possono essere anche espressioni complesse o anche delle chiamate a funzione. Verranno presi in considerazione solamente se non verrà fornito alcun valore.
+I valori di default possono essere anche espressioni complesse o chiamate a funzione. Verranno presi in considerazione solamente se non verrà fornito alcun valore.
+
+
+Ad esempio, qui usiamo la funzione `prompt` per due defaults:
 
-<<<<<<< HEAD
-Ad esempio, qui usiamo la funzione `prompt` come default. La chiamata avverrà solamente nel secondo caso:
-=======
-For instance, here we use the `prompt` function for two defaults:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 ```js run
 // viene eseguito solo il prompt per il cognome
@@ -292,23 +231,19 @@ alert(name);    // Julius (dall'array)
 alert(surname); // qualsiasi cosa provenga dal prompt
 ```
 
-Please note: the `prompt` will run only for the missing value (`surname`).
+Attenzione: la funzione `prompt` verrà eseguita solo per il valore vancante (`surname`).
 
 ## Destrutturazione di oggetti
 
-L'assegnamento di destrutturazione funziona allo stesso modo con gli oggetti.
+L'assegnamento di destrutturazione funziona anche con gli oggetti.
 
 La sintassi è:
 
 ```js
 let {var1, var2} = {var1:…, var2:…}
 ```
 
-<<<<<<< HEAD
 Abbiamo un oggetto alla destra dell'assegnazione, che vogliamo dividere in variabili. Nel lato sinistro abbiamo un "pattern" di proprietà corrispondenti. In questo semplice caso, abbiamo una lista di variabili raggruppate tra parentesi `{...}`.
-=======
-We should have an existing object at the right side, that we want to split into variables. The left side contains an object-like "pattern" for corresponding properties. In the simplest case, that's a list of variable names in `{...}`.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 Ad esempio:
 
@@ -329,12 +264,10 @@ alert(height); // 200
 ```
 
 <<<<<<< HEAD
-Le proprietà `options.title`, `options.width` e `options.height` vengono assegnate alle variabili corrispondenti. L'ordine non ha importanza. Questo codice funzionerebbe allo stesso modo:
-=======
-Properties `options.title`, `options.width` and `options.height` are assigned to the corresponding variables. 
+Le proprietà `options.title`, `options.width` e `options.height` vengono assegnate alle variabili corrispondenti.
+
+L'ordine non ha importanza. Questo codice funzionerebbe comunque:
 
-The order does not matter. This works too:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 ```js
 // cambiato l'ordine delle proprietà in let {...}
@@ -343,11 +276,9 @@ 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.
 
-<<<<<<< HEAD
-Se volessimo assegnare una proprietà ad una variabile con un altro nome, ad esempio, la proprietà `options.width` vogliamo inserirla in una variabile chiamata `w`, allora possiamo specificarlo con i due punti:
-=======
-If we want to assign a property to a variable with another name, for instance, make `options.width` go into the variable named `w`, then we can set the variable name using a colon:
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+
+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:
+
 
 ```js run
 let options = {