Merge pull request #239 from Dorin-David/Article/weakmap-weakset

Article/weakmap weakset

Author: longo-andrea

1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md

@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-Utilizzeremo la variante con le lettere ordite come chiave di una map per memorizzare un solo valore:
+Utilizzeremo la variante con le lettere ordinate come chiave di una map per memorizzare un solo valore:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // dividi la parola in lettere, ordinale e ricongiungile 
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -53,7 +53,7 @@ map.set(sorted, word);
 
 Se abbiamo già incontrato una parola con la stessa forma, la sovrascriviamo con quella nuova, in modo tale da avere sempre una sola occorrenza all'interno della map. 
 
-Alla fine `Array.from(map.values())` prende un iteratore sui valori di map (non abbiamo bisogno delle chiavi nel risultato) e ne ritorna un array.
+Alla fine `Array.from(map.values())` prende un iteratore sui valori di `map` (non abbiamo bisogno delle chiavi nel risultato) e ne ritorna un array.
 
 Qui potremmo anche utilizzare un normale oggetto piuttosto di `Map`, poiché le chiavi sono stringhe.
 

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Chiavi iterabili
 
-Vorremmo avere un array di `map.keys()` in una variabile, quindi poterle applicare un metodo specifico degli arrays, ad esempio `.push`.
+Vorremmo avere un array di `map.keys()` in una variabile, quindi potergli applicare un metodo specifico degli arrays, ad esempio `.push`.
 
 Ma c'è un problema:
 

1-js/05-data-types/07-map-set/article.md

@@ -3,10 +3,10 @@
 
 Finora abbiamo appreso le nozioni di base riguardo le seguenti strutture dati:
 
-- Oggetti, per la memorizzazione di collezioni identificate da chiave.
+- Oggetti, per la memorizzazione di collezioni identificate da una chiave.
 - Array, per la memorizzazione di collezioni ordinate.
 
-Queste non sono però sufficienti nella vita reale. Per esistono ulteriori strutture dati come `Map` e `Set`.
+Queste però non sono sufficienti. Esistono ulteriori strutture dati, come `Map` e `Set`.
 
 ## Map
 
@@ -42,7 +42,7 @@ alert( map.size ); // 3
 Come abbiamo potuto osservare, a differenza degli oggetti, le chiavi non vengono convertite a stringa. Sono quindi ammesse chiavi di qualunque tipo.
 
 ```smart header="`map[key]` non è il modo corretto di utilizzare una `Map`"
-Anche se `map[key]` funziona, ad esempio possiamo impostare `map[key] = 2`, equivale a trattare una `map` come un oggetto semplice, con tutte le limitazioni correlate agli oggetti.
+Anche se `map[key]` funziona, ad esempio possiamo impostare `map[key] = 2`, questo equivale a trattare`map` come un oggetto semplice, con tutte le limitazioni correlate.
 
 Quindi dovremmo utilizzare i metodi dedicati a `map`: `set`, `get` e gli altri.
 ```
@@ -54,7 +54,7 @@ Ad esempio:
 ```js run
 let john = { name: "John" };
 
-// per ogni utente, memorizziamo il contatore di visite
+// per ogni utente, memorizziamo il contatore delle visite
 let visitsCountMap = new Map();
 
 // john è la chiave
@@ -63,7 +63,7 @@ visitsCountMap.set(john, 123);
 alert( visitsCountMap.get(john) ); // 123
 ```
 
-Il fatto di poter utilizzare oggetti come chiave è una delle caratteristiche più importanti fornite dalla struttura dati `Map`. Per chiavi di tipo string, un normale `Object` può andare bene, ma non vale lo stesso per chiavi di tipo oggetto.
+Il fatto di poter utilizzare oggetti come chiavi è una delle caratteristiche più importanti fornite dalla struttura dati `Map`. In un normale `Object` una chiave di tipo stringa può andare bene, ma non vale lo stesso per le chiavi di tipo oggetto.
 
 Proviamo:
 
@@ -80,16 +80,16 @@ alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 
-Dal momento che `visitsCountObj` è un oggetto, converte tutte le chiavi, come `john` e `ben` a stringhe, quindi otteniamo la chiave `"[object Object]"`. Senza dubbio non ciò che ci aspettavamo.
+Dal momento che `visitsCountObj` è un oggetto, converte tutte le chiavi, come `john` e `ben`, a stringhe, quindi otteniamo la chiave `"[object Object]"`. Senza dubbio non ciò che ci aspettavamo.
 
-```smart header="How `Map` confronta le chiavi"
+```smart header="Come `Map` confronta le chiavi"
 Per verificare l'equivalenza delle chiavi, `Map`utilizza l'algoritmo [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). E' quasi la stessa cosa dell'uguaglianza stretta `===`, con la differenza che `NaN` viene considerato uguale a `NaN`. Quindi anche `NaN` può essere utilizzato come chiave.
 
-L'algoritmo di confronto non può essere ne cambiato ne modificato.
+L'algoritmo di confronto non può essere né cambiato né modificato.
 ```
 
 ````smart header="concatenamento"
-Ogni chiamata a `map.set` la mappa stessa, quindi possiamo concatenare le chiamate:
+Ogni chiamata a `map.set` ritorna la mappa stessa, quindi possiamo concatenare le chiamate:
 
 ```js
 map.set('1', 'str1')
@@ -103,8 +103,8 @@ map.set('1', 'str1')
 Per iterare attraverso gli elementi di `Map`, esistono 3 metodi:
 
 - `map.keys()` -- ritorna un oggetto per iterare sulle chiavi,
-- `map.values()` -- ritorna un oggetto per iterar sui valori,
-- `map.entries()` -- ritorna un oggetto per iterare sulle voci `[key, value]`, ed è il metodo utilizzato di default nel ciclo `for..of`.
+- `map.values()` -- ritorna un oggetto per iterare sui valori,
+- `map.entries()` -- ritorna un oggetto per iterare sulle coppie `[key, value]`, ed è il metodo utilizzato di default nel ciclo `for..of`.
 
 Ad esempio:
 
@@ -146,7 +146,7 @@ recipeMap.forEach( (value, key, map) => {
 
 ## Object.entries: Map da Object
 
-Durante la fase di creazione di una `Map`, possiamo passargli un array (o qualsiasi altra struttura dati iterabile) con coppie chiave/valore per inizializzare la `Map`, come nel seguente esempio:
+Durante la fase di creazione di una `Map`, possiamo passarle un array (o qualsiasi altra struttura dati iterabile) con coppie chiave/valore per inizializzare la `Map`, come nel seguente esempio:
 
 ```js run
 // array di coppie [chiave, valore] 
@@ -161,7 +161,7 @@ alert( map.get('1') ); // str1
 
 Se abbiamo un semplice oggetto, e vogliamo utilizzarlo per creare una `Map`, possiamo utilizzare un metodo integrato degli oggetti [Object.entries(obj)](mdn:js/Object/entries) il quale ritorna un array di coppie chiave/valore nello stesso formato.
 
-Quindi possiamo creare una `Map` da un oggetto come questo:
+Quindi possiamo creare una `Map` da un oggetto, così:
 
 ```js run
 let obj = {
@@ -192,14 +192,14 @@ let prices = Object.fromEntries([
   ['meat', 4]
 ]);
 
-// now prices = { banana: 1, orange: 2, meat: 4 }
+// ora prices = { banana: 1, orange: 2, meat: 4 }
 
 alert(prices.orange); // 2
 ```
 
 Possiamo utilizzare il metodo `Object.fromEntries` per ottenere un oggetto partendo da una `Map`.
 
-Ad esempio memorizziamo i dati in una `Map`, ma abbiamo bisogno di passarli ad un codice di terze parti che si aspetta un oggetto.
+Ad esempio, memorizziamo i dati in una `Map`, ma abbiamo bisogno di passarla ad un codice di terze parti che si aspetta un oggetto.
 
 Quindi:
 
@@ -221,7 +221,7 @@ alert(obj.orange); // 2
 
 Una chiamata a `map.entries()` ritorna un array di coppie chiave/valore, esattamente nel formato richiesto da `Object.fromEntries`.
 
-Possiamo rendere la rica `(*)` ancora più corta:
+Possiamo rendere la riga `(*)` ancora più corta:
 ```js
 let obj = Object.fromEntries(map); // omettendo .entries()
 ```
@@ -235,15 +235,15 @@ Un `Set` è un tipo di collezione speciale - "set di valori" (senza chiavi), dov
 I suoi metodi principali sono:
 
 - `new Set(iterable)` -- crea il set, e se gli viene fornito un oggetto `iterabile` (solitamente un array), ne copia i valori nel set.
-- `set.add(value)` -- aggiunge un valore, e ritorna il set.
+- `set.add(value)` -- aggiunge un valore, ritorna il set.
 - `set.delete(value)` -- rimuove il valore, ritorna `true` se `value` esiste, altrimenti `false`.
 - `set.has(value)` -- ritorna `true` se il valore esiste nel set, altrimenti `false`.
 - `set.clear()` -- rimuove tutti i valori dal set.
-- `set.size` -- ritorna la dimensione del set, ovvero il numero di valori contenuti.
+- `set.size` -- ritorna il numero dei valori contenuti.
 
-La principale caratteristica dei set è che ripetute chiamate di `set.add(value)` con lo stesso valore, non fanno nulla. Questo è il motivo per cui ogni valore può comparire una sola volta in un `Set`.
+La principale caratteristica dei set è che ripetute chiamate di `set.add(value)` con lo stesso valore non fanno nulla. Questo è il motivo per cui in un `Set` ogni valore può comparire una sola volta.
 
-Ad esempio, abbiamo diversi arrivi di visitatori, e vorremmo ricordarli tutti. Ma visite ripetute dello stesso non dovrebbe portare a duplicati. Un visitatore deve essere conteggiato una volta sola.
+Ad esempio, abbiamo diversi arrivi di visitatori, e vorremmo ricordarli tutti. Ma visite ripetute dello stesso utente non dovrebbe portare a duplicati. Un visitatore deve essere conteggiato una volta sola.
 
 `Set` è esattamente la struttura dati che fa al caso nostro:
 
@@ -269,7 +269,7 @@ for (let user of set) {
 }
 ```
 
-L'alternativa a `Set` potrebbe essere un array di visitatori, aggiungendo del codice per verificare ogni inserimento ed evitare i duplicati, utilizzando [arr.find](mdn:js/Array/find). Ma le performance sarebbero di molto peggiori, perché questo metodo attraversa tutto l'array per verificare ogni elemento. `Set` è ottimizzato internamente per controllo di unicità.
+L'alternativa a `Set` potrebbe essere un array di visitatori, e un codice per verificare ogni inserimento ed evitare duplicati, utilizzando [arr.find](mdn:js/Array/find). Ma la performance sarebbe molto inferiore, perché questo metodo attraversa tutto l'array per verificare ogni elemento. `Set` è ottimizzato internamente per il controllo di unicità.
 
 ## Iterare un Set
 
@@ -286,36 +286,36 @@ set.forEach((value, valueAgain, set) => {
 });
 ```
 
-Da notare una cosa divertente. La funzione di callback fornita al `forEach` ha 3 argomenti: un `value`, poi *lo stesso valore* `valueAgain`, e poi l'oggetto su cui iterare. Proprio cosi, lo stesso valore appare due volte nella lista degli argomenti.
+Da notare una cosa divertente. La funzione callback fornita a `forEach` ha 3 argomenti: un `value`, poi *lo stesso valore* `valueAgain`, e poi l'oggetto riferito da `this`. Proprio così, lo stesso valore appare due volte nella lista degli argomenti.
 
-Questo accade per questioni di compatibilità con `Map` in cui la funzione callback fornita al `forEach` possiede tre argomenti. E' un po strano. Però in alcuni casi può aiutare rimpiazzare `Map` con `Set`, e vice versa.
+Questo accade per questioni di compatibilità con `Map`, in cui la funzione callback fornita al `forEach` possiede tre argomenti. E' un po' strano, ma in alcuni casi può aiutare rimpiazzare `Map` con `Set`, e vice versa.
 
-Sono supportati anche i metodi di iterazione offerti da `Map`:
+Sono supportati anche i metodi di iterazione di `Map`:
 
 - `set.keys()` -- ritorna un oggetto per iterare sui valori,
 - `set.values()` -- lo stesso di `set.keys()`, per compatibilità con `Map`,
 - `set.entries()` -- ritorna un oggetto per iterare sulle voci `[value, value]`, esiste per compatibilità con `Map`.
 
 ## Riepilogo
 
-`Map` -- è una collezione di valori identificati da chiave.
+`Map` è una collezione di valori identificati da chiave.
 
 Metodi e proprietà:
 
 - `new Map([iterable])` -- crea la mappa, accetta un oggetto iterabile (opzionale, e.g. array) di coppie `[key,value]` per l'inizializzazione.
 - `map.set(key, value)` -- memorizza il valore con la chiave fornita.
-- `map.get(key)` -- ritorna il valore associata alla chiave, `undefined` se la `key` non è presente nella `Map`.
+- `map.get(key)` -- ritorna il valore associato alla chiave, `undefined` se la `key` non è presente nella `Map`.
 - `map.has(key)` -- ritorna `true` se la `key` esiste, `false` altrimenti.
 - `map.delete(key)` -- rimuove il valore associato alla chiave.
 - `map.clear()` -- rimuove ogni elemento dalla mappa.
-- `map.size` -- ritorna il numero di elementi contenuti nella map.
+- `map.size` -- ritorna il numero di elementi contenuti nella `map`.
 
 Le differenze da un `Object` standard:
 
 - Le chiavi possono essere di qualsiasi tipo, anche oggetti.
 - Possiede metodi aggiuntivi, come la proprietà `size`.
 
-`Set` -- è una collezione di valori unici.
+`Set` è una collezione di valori unici.
 
 Metodi e proprietà:
 
@@ -324,6 +324,6 @@ Metodi e proprietà:
 - `set.delete(value)` -- rimuove il valore, ritorna `true` se `value` esiste, `false` altrimenti.
 - `set.has(value)` -- ritorna `true` se il valore esiste nel set, `false` altrimenti.
 - `set.clear()` -- rimuove tutti i valori dal set.
-- `set.size` -- ritorna la dimensione del set, ovvero il numero di valori contenuti.
+- `set.size` -- ritorna il numero di valori contenuti.
 
-L'iterazione su `Map` e `Set` segue sempre l'ordine di inserimento, quindi posso essere definite delle collezioni ordinate, non è però possibile riordinare gli elementi oppure ottenere un valore tramite il suo indice.
+L'iterazione su `Map` e `Set` segue sempre l'ordine di inserimento, quindi possono essere definite delle collezioni ordinate; non è però possibile riordinare gli elementi oppure ottenere un valore tramite il suo indice.

1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md

@@ -1,36 +1,47 @@
+Memorizziamo i messaggi letti in `WeakSet`:
+
+```js run
+let messages = [
+  {text: "Hello", from: "John"},
   {text: "How goes?", from: "John"},
   {text: "See you soon", from: "Alice"}
 ];
 
 let readMessages = new WeakSet();
 
-// two messages have been read
+//due messaggi sono stati letti
 readMessages.add(messages[0]);
 readMessages.add(messages[1]);
-// readMessages has 2 elements
+// readMessages ha due elementi
 
-// ...let's read the first message again!
+//...leggiamo nuovamente il primo messaggio!
 readMessages.add(messages[0]);
-// readMessages still has 2 unique elements
+// readMessages ha 2 elementi unici
 
-// answer: was the message[0] read?
+//risposta: message[0] è stato letto?
 alert("Read message 0: " + readMessages.has(messages[0])); // true
 
 messages.shift();
-// now readMessages has 1 element (technically memory may be cleaned later)
+// ora readMessages ha un elemento (tecnicamente la memoria potrebbe essere ripulita dopo)
 ```
 
 La struttura `WeakSet` consente di memorizzare un insieme di messaggi e di verificare molto rapidamente la presenza di un dato messaggio.
 
 Viene ripulita automaticamente. Il lato negativo è che non possiamo eseguire iterazioni. Non possiamo ottenere direttamente "tutti i messaggi letti". Ma possiamo farlo iterando su tutti i messaggi e filtrando tutti quelli che sono presenti nel set.
 
-P.S. Aggiungere una proprietà ad ogni messaggio potrebbe essere pericoloso, se questo oggetto viene gestito dal codice di un'altra persona;  per evitare conflitti possiamo utilizzare un *symbol*.
+Another, different solution could be to add a property like `message.isRead=true` to a message after it's read. As messages objects are managed by another code, that's generally discouraged, but we can use a symbolic property to avoid conflicts.
+
+Un'altra soluzione potrebbe essere aggiungere una proprietà come `message.isRead=true`, ma farlo potrebbe essere pericoloso, se questo oggetto viene gestito dal codice di un'altra persona;  per evitare conflitti possiamo utilizzare un *symbol*.
 
 Come qui:
 ```js
-// the symbolic property is only known to our code
+//la proprietà simbolica è visibile solo al nostro codice 
 let isRead = Symbol("isRead");
 messages[0][isRead] = true;
 ```
 
-Ora anche se qualcun'altro utilizza `for..in` per avere accesso a tutte le proprietà di messagge, la nostra etichetta sarà segreta.
+Ora anche se qualcun altro utilizza `for..in` per avere accesso a tutte le proprietà di messagge, la nostra proprietà sarà segreta.
+
+
+Although symbols allow to lower the probability of problems, using `WeakSet` is better from the architectural point of view.
+Sebbene i simboli permettano una minore probabilità di problemi, utilizzare `weakSet` è meglio da un punto di vista architetturale.

1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md

@@ -16,4 +16,4 @@ let messages = [
 
 Ora la domanda è: quale struttura di dati converrebbe utilizzare per memorizzare l'informazione: "quando è stato letto il messaggio?".
 
-Nel compito precedente la necessità era semplicemente di memorizzare la lettura del messaggio. Ora abbiamo bisogno di memorizzare anche la data, anche in questo caso, se il messaggio viene eliminato questa dovrebbe sparire.
+Nel compito precedente la necessità era semplicemente di memorizzare la lettura del messaggio. Ora abbiamo bisogno di memorizzare anche la data; anche in questo caso, se il messaggio viene eliminato questa dovrebbe sparire.