From cd5ac908201b777cc63c81b324d493101138769b Mon Sep 17 00:00:00 2001
From: vplentinax <jc.lerebours.vp@hotmail.com>
Date: Thu, 18 Jun 2020 17:10:08 -0400
Subject: [PATCH 01/24] mapset

---
 .../07-map-set/01-array-unique-map/task.md    |  3 +
 .../07-map-set/02-filter-anagrams/solution.md | 20 +++-
 .../07-map-set/02-filter-anagrams/task.md     |  4 +
 .../07-map-set/03-iterable-keys/solution.md   |  2 +
 .../07-map-set/03-iterable-keys/task.md       |  6 +-
 1-js/05-data-types/07-map-set/article.md      | 99 ++++++++++---------
 6 files changed, 84 insertions(+), 50 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index b11b8546d..0f05961f9 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -2,6 +2,7 @@ importance: 5
 
 ---
 
+
 # Filtrar miembros únicos del array
 
 Permita que `arr` sea un array.
@@ -21,6 +22,8 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
+
+
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
 P.D.S. Use `Set` para almacenar valores únicos.
diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
index 21fa385c1..b22831136 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
@@ -3,6 +3,7 @@ Para encontrar todos los anagramas, dividamos cada palabra en letras y las orden
 
 Por ejemplo:
 
+
 ```
 nap, pan -> anp
 ear, era, are -> aer
@@ -10,19 +11,24 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-Utilizaremos las variantes ordenadas por letras como propiedades de Map para almacenar solo un valor por cada propiedad:
+
+Utilizaremos las variantes ordenadas por letras como claves de Map para almacenar solo un valor por cada clave:
+
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
+
     // dividir la palabra por letras, ordenarlas y volver a unir
+
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
     map.set(sorted, word);
   }
+
   return Array.from(map.values());
 }
 
@@ -30,17 +36,22 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
 alert( aclean(arr) );
 ```
+
+
 La clasificación de letras se realiza mediante la cadena de llamadas en la línea `(*)`.
 
 Por conveniencia la dividimos en múltiples líneas:
 
 ```js
 let sorted = arr[i] // PAN
+
   .toLowerCase() // pan
   .split('') // ['p','a','n']
   .sort() // ['a','n','p']
   .join(''); // anp
 ```
+
+
 Dos palabras diferentes`'PAN'` y `'nap'` reciben la misma forma ordenada por letras `'anp'`.
 
 La siguiente línea pone la palabra en el Map:
@@ -50,11 +61,12 @@ La siguiente línea pone la palabra en el Map:
 map.set(sorted, word);
 ```
 
-Si alguna vez volvemos a encontrar una palabra con la misma forma ordenada por letras, sobrescribiría el valor anterior con la misma propiedad en Map. Por lo tanto, siempre tendremos como máximo una palabra ordenada por letras.
 
-Al final, `Array.from (map.values())` toma un valor iterativo sobre los valores de Map (no necesitamos propiedades en el resultado) y devuelve un array de ellos.
+Si alguna vez volvemos a encontrar una palabra con la misma forma ordenada por letras, sobrescribiría el valor anterior con la misma clave en Map. Por lo tanto, siempre tendremos como máximo una palabra ordenada por letras.
+
+Al final, `Array.from (map.values())` toma un valor iterativo sobre los valores de Map (no necesitamos claves en el resultado) y devuelve un array de ellos.
 
-Aquí también podríamos usar un objeto plano en lugar del `Map`, porque las propiedades son strings.
+Aquí también podríamos usar un objeto plano en lugar del `Map`, porque las claves son strings.
 
 Así es como puede verse la solución:
 
diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
index 508c03203..15622e131 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
@@ -8,12 +8,14 @@ importance: 4
 
 Por ejemplo:
 
+
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
+
 Escriba una función `aclean(arr)` que devuelva un array limpio de anagramas.
 
 Por ejemplo:
@@ -22,7 +24,9 @@ Por ejemplo:
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
+
 alert( aclean(arr) ); // "nap,teachers,ear" o "PAN,cheaters,era"
 ```
+
 Es decir, de cada grupo de anagramas debe quedar solo una palabra, sin importar cual.
 
diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
index 0d7fa149e..9d70bba9a 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
@@ -1,8 +1,10 @@
 
+
 Eso es porque `map.keys()` devuelve un iterable, pero no un array.
 
 Podemos convertirlo en un array usando `Array.from`:
 
+
 ```js run
 let map = new Map();
 
diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
index be3f1e034..666fdca55 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -2,12 +2,13 @@ importance: 5
 
 ---
 
-# Propiedades iterables
+# Claves iterables
 
 Nos gustaría obtener un array de `map.keys()` en una variable y luego aplicarle métodos específicos de array, ej. .push.
 
 Pero eso no funciona:
 
+
 ```js run
 let map = new Map();
 
@@ -16,10 +17,13 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
+
 // Error: keys.push no es una función
+
 keys.push("more");
 */!*
 ```
 
+
 ¿Por qué? ¿Cómo podemos arreglar el código para que funcione `keys.push`?
 
diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 0259217bd..fa535f76a 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -1,23 +1,24 @@
+
 # Map y Set
 
 Hasta este momento, hemos aprendido sobre las siguientes estructuras de datos:
 
-- Objetos para almacenar colecciones de propiedades.
+- Objetos para almacenar colecciones de claves.
 - Arrays para almacenar colecciones ordenadas.
 
 Pero eso no es suficiente para la vida real. Por eso también existen Map y Set.
 
 ## Map
 
-[Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) es una colección de elementos de datos con propiedad, al igual que un objeto, y valor. Pero la principal diferencia es que Map permite propiedades de cualquier tipo.
+[Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) es una colección de elementos de datos con clave, al igual que un objeto, y valor. Pero la principal diferencia es que Map permite claves de cualquier tipo.
 
 Los métodos y propiedades son:
 
 - `new Map()` -- crea el mapa.
-- `map.set(propiedad, valor)` -- almacena el valor para la propiedad.
-- `map.get(propiedad)` -- devuelve el valor de la propiedad: será `undefined` si la `propiedad` no exite en Map.
-- `map.has(propiedad)` -- devuelve`true` si la `propiedad` exite, y `false` si no existe.
-- `map.delete(propiedad)` -- elimina los valores de la propiedad.
+- `map.set(clave, valor)` -- almacena el valor para la clave.
+- `map.get(clave)` -- devuelve el valor de la clave: será `undefined` si la `clave` no exite en Map.
+- `map.has(clave)` -- devuelve`true` si la `clave` exite, y `false` si no existe.
+- `map.delete(clave)` -- elimina los valores de la clave.
 - `map.clear()` -- limpia el Map.
 - `map.size` -- retorna el número del elemento actual en el recuento de elementos en el Map.
 
@@ -25,26 +26,29 @@ Por ejemplo:
 
 ```js run
 let map = new Map();
-map.set('1', 'str1');   // un string como propiedad
-map.set(1, 'num1');     // un número como propiedad
-map.set(true, 'bool1'); // un booleano como propiedad
-// recuerda el objeto regular? convertiría las propiedades en un string
-// Map mantiene el tipo de dato en las propiedades, por lo que estas dos son diferentes:
+
+map.set('1', 'str1');   // un string como clave
+map.set(1, 'num1');     // un número como clave
+map.set(true, 'bool1'); // un booleano como clave
+
+// recuerda el objeto regular? convertiría las claves en un string
+// Map mantiene el tipo de dato en las claves, por lo que estas dos son diferentes:
+
 alert( map.get(1)   ); // 'num1'
 alert( map.get('1') ); // 'str1'
 
 alert( map.size ); // 3
 ```
 
-Como podemos ver, a diferencia de los objetos, las propiedades no se convierten en strings. Cualquier tipo de propiedad es posible en un Map.
+Como podemos ver, a diferencia de los objetos, las claves no se convierten en strings. Cualquier tipo de clave es posible en un Map.
 
-```smart header="map[propiedad] no es la forma correcta para usar Map"
-Aunque el map[propiedad] también funciona, por ejemplo, podemos establecer map[propiedad] = 2, esto es tratar a map como un objeto JavaScript simple, por lo que implica todas las limitaciones correspondientes (sin objetos como propiedad, etc.).
+```smart header="map[clave] no es la forma correcta para usar Map"
+Aunque el `map[clave]` también funciona, por ejemplo, podemos establecer `map[clave]` = 2, esto es tratar a `map` como un objeto JavaScript simple, por lo que implica todas las limitaciones correspondientes (sin objetos como clave, etc.).
 
-Por lo tanto, deberíamos usar los métodos de `Map`: set, get, etc.
+Por lo tanto, deberíamos usar los métodos de `Map`: `set`, `get`, etc.
 ```
 
-**El mapa también puede usar objetos como propiedades.**
+**El mapa también puede usar objetos como claves.**
 
 Por ejemplo:
 
@@ -55,30 +59,33 @@ let john = { name: "John" };
 // para cada usuario, almacenemos el recuento de visitas
 let visitsCountMap = new Map();
 
-// John es la propiedad para el Map
+// John es la clave para el Map
+
 visitsCountMap.set(john, 123);
 
 alert( visitsCountMap.get(john) ); // 123
 ```
-El uso de objetos como propiedades es una de las características de `Map` más notables e importantes. Para las propiedades de tipo string, `Object` puede estar bien, pero no para las propiedades de tipo objeto.
+
+El uso de objetos como claves es una de las características de `Map` más notables e importantes. Para las claves de tipo string, `Object` puede estar bien, pero no para las claves de tipo objeto.
 
 Intentémoslo:
 
+
 ```js run
 let john = { name: "John" };
 
 let visitsCountObj = {}; // intenta usar un objeto
 
-visitsCountObj[john] = 123; // intenta usar el objeto john como propiedad
+visitsCountObj[john] = 123; // intenta usar el objeto john como clave
 
 // Esto es lo que se escribió!
 alert( visitsCountObj["[object Object]"] ); // 123
 ```
 
-Como `visitsCountObj` es un objeto, convierte todas las propiedades, como John en string, por lo que tenemos la propiedad de tipo string `"[objeto Objeto]"`. Definitivamente no es lo que queremos.
+Como `visitsCountObj` es un objeto, convierte todas las claves, como John en string, por lo que tenemos la clave de tipo string `"[objeto Objeto]"`. Definitivamente no es lo que queremos.
 
-```smart header="Cómo `Map` compara las propiedades"
-`Map` utiliza el algoritmo [SameValueZero](https://tc39.es/ecma262/#sec-samevaluezero). Es aproximadamente lo mismo que la igualdad estricta `===`, pero la diferencia es que `NaN` se considera igual a `NaN`. Por lo tanto, `NaN` también se puede usar como propiedad.
+```smart header="Cómo Map compara las claves" 
+`Map` utiliza el algoritmo [SameValueZero](https://tc39.es/ecma262/#sec-samevaluezero). Es aproximadamente lo mismo que la igualdad estricta `===`, pero la diferencia es que `NaN` se considera igual a `NaN`. Por lo tanto, `NaN` también se puede usar como clave.
 
 Este algoritmo no se puede cambiar ni personalizar.
 ```
@@ -96,9 +103,9 @@ map.set('1', 'str1')
 ## Iteración sobre Map
 Para recorrer un `Map`, hay 3 métodos:
 
-- `map.keys()` – devuelve un iterable para las propiedades.
+- `map.keys()` – devuelve un iterable para las claves.
 - `map.values()` – devuelve un iterable para los valores.
-- `map.entries()` – devuelve un iterable para las entradas `[propiedad, valor]`, se usa por defecto en `for..of`.
+- `map.entries()` – devuelve un iterable para las entradas `[clave, valor]`, se usa por defecto en `for..of`.
 
 Por ejemplo:
 
@@ -109,7 +116,7 @@ let recipeMap = new Map([
   ['cebollas',    50]
 ]);
 
-// iterando sobre las propiedades (verduras)
+// iterando sobre las claves (verduras)
 for (let vegetable of recipeMap.keys()) {
   alert(vegetable); // pepino, tomates, cebollas
 }
@@ -120,7 +127,7 @@ for (let amount of recipeMap.values()) {
   alert(amount); // 500, 350, 50
 }
 
-// iterando sobre las entradas [propiedad, valor]
+// iterando sobre las entradas [clave, valor]
 for (let entry of recipeMap) { // lo mismo que recipeMap.entries()
   alert(entry); // pepino,500 (etc)
 }
@@ -132,7 +139,7 @@ La iteración va en el mismo orden en que se insertaron los valores. `Map` conse
 Además de eso, `Map` tiene un método `forEach` incorporado, similar a `Array`:
 
 ```js
-// recorre la función para cada par (propiedad, valor)
+// recorre la función para cada par (clave, valor)
 recipeMap.forEach( (value, key, map) => {
   alert(`${key}: ${value}`); // pepino: 500 etc
 });
@@ -140,10 +147,11 @@ recipeMap.forEach( (value, key, map) => {
 
 ## Object.entries: Map desde Objeto
 
-Cuando se crea un `Map`, podemos pasar un array (u otro iterable) con pares propiedad / valor para la inicialización, de esta manera:
+Cuando se crea un `Map`, podemos pasar un array (u otro iterable) con pares clave / valor para la inicialización, de esta manera:
 
 ```js run
-// array de [propiedad, valor]
+// array de [clave, valor]
+
 let map = new Map([
   ['1',  'str1'],
   [1,    'num1'],
@@ -152,7 +160,8 @@ let map = new Map([
 
 alert( map.get('1') ); // str1
 ```
-Aquí hay un método incorporado [Object.entries(obj)](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/entries) que devuelve un array de pares propiedad / valor para un objeto exactamente en ese formato.
+
+Aquí hay un método incorporado [Object.entries(obj)](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/entries) que devuelve un array de pares clave / valor para un objeto exactamente en ese formato.
 
 Entonces podemos inicializar un mapa desde un objeto como este:
 
@@ -167,12 +176,12 @@ let map = new Map(Object.entries(obj));
 alert( map.get('name') ); // John
 ```
 
-Aquí, `Object.entries` devuelve el array de pares propiedad / valor: [["" name "," John "], [" age ", 30]]. Eso es lo que necesita `Map`.
+Aquí, `Object.entries` devuelve el array de pares clave / valor: [["" name "," John "], [" age ", 30]]. Eso es lo que necesita `Map`.
 
 ## Object.fromEntries: Objeto desde Map
 Acabamos de ver cómo crear un `Map` a partir de un objeto simple con `Object.entries (obj).`
 
-Existe el método `Object.fromEntries` que hace lo contrario: dado un array de pares [propiedad, valor], crea un objeto a partir de ellos:
+Existe el método `Object.fromEntries` que hace lo contrario: dado un array de pares [clave, valor], crea un objeto a partir de ellos:
 
 ```js run
 let prices = Object.fromEntries([
@@ -205,17 +214,17 @@ let obj = Object.fromEntries(map.entries()); // hace un objeto simple
 alert(obj.orange); // 2
 ```
 
-Una llamada a `map.entries()` devuelve un array de pares propiedad / valor, exactamente en el formato correcto para `Object.fromEntries.`
+Una llamada a `map.entries()` devuelve un array de pares clave / valor, exactamente en el formato correcto para `Object.fromEntries.`
 
 También podríamos acortar la línea 6 del ejemplo anterior:
 
 ```js
 let obj = Object.fromEntries(map); // omitimos .entries()
 ```
-Es lo mismo, porque `Object.fromEntries` espera un objeto iterable como argumento. No necesariamente un array. Y la iteración estándar para el `Map` devuelve los mismos pares propiedad / valor que `map.entries()`. Entonces obtenemos un objeto simple con las mismas propiedades / valores que `Map`.
+Es lo mismo, porque `Object.fromEntries` espera un objeto iterable como argumento. No necesariamente un array. Y la iteración estándar para el `Map` devuelve los mismos pares clave / valor que `map.entries()`. Entonces obtenemos un objeto simple con las mismas claves / valores que `Map`.
 
 ## Set
-`Set` es una colección de tipo especial: "conjunto de valores" (sin propiedades), donde cada valor puede aparecer solo una vez.
+`Set` es una colección de tipo especial: "conjunto de valores" (sin claves), donde cada valor puede aparecer solo una vez.
 
 Sus principales métodos son:
 
@@ -259,6 +268,7 @@ La alternativa a `Set` podría ser un array de usuarios y el código para verifi
 ## Iteración sobre Set
 Podemos recorrer `Set` con `for..of` o usando `forEach`:
 
+
 ```js run
 let set = new Set(["oranges", "apples", "bananas"]);
 
@@ -277,25 +287,25 @@ Eso es por compatibilidad con `Map` donde la función callback tiene tres argume
 
 También soporta los mismos métodos que `Map` tiene para los iteradores:
 
-- `set.keys()` – devuelve un iterable para las propiedades.
+- `set.keys()` – devuelve un iterable para las claves.
 - `set.values()` – lo mismo que `set.keys()`, por su compatibilidad con `Map`.
-- `set.entries()` – devuelve un iterable para las entradas `[propiedad, valor]`, por su compatibilidad con `Map`.
+- `set.entries()` – devuelve un iterable para las entradas `[clave, valor]`, por su compatibilidad con `Map`.
 
 ## Resumen
-`Map`: es una colección de valores con propiedad.
+`Map`: es una colección de valores con clave.
 
 Métodos y propiedades:
 - `new Map()` -- crea el mapa.
-- `map.set(propiedad, valor)` -- almacena el valor para la propiedad.
-- `map.get(propiedad)` -- devuelve el valor de la propiedad: será `undefined` si la `propiedad` no exite en Map.
-- `map.has(propiedad)` -- devuelve`true` si la `propiedad` exite, y `false` si no existe.
-- `map.delete(propiedad)` -- elimina los valores de la propiedad.
+- `map.set(clave, valor)` -- almacena el valor para la clave.
+- `map.get(clave)` -- devuelve el valor de la clave: será `undefined` si la `clave` no exite en Map.
+- `map.has(clave)` -- devuelve`true` si la `clave` exite, y `false` si no existe.
+- `map.delete(clave)` -- elimina los valores de la clave.
 - `map.clear()` -- limpia el Map.
 - `map.size` -- retorna el número del elemento actual en el recuento de elementos en el Map.
 
 La diferencia con `Objeto` regular:
-- Cualquier propiedad, los objetos tambien pueden ser propiedads.
-- Adicionalmente tiene métodos que nos convienen, como la propiedad `size`.
+- Cualquier clave, los objetos tambien pueden ser claves.
+- Adicionalmente tiene métodos que nos convienen, como la clave `size`.
 
 `Set`: es una colección de valores únicos.
 
@@ -308,4 +318,3 @@ Métodos y propiedades:
 - `set.size` -- es el contador de los elementos.
 
 La iteración sobre `Map` y `Set` siempre está en el orden de inserción, por lo que no podemos decir que estas colecciones están desordenadas, pero no podemos reordenar elementos u obtener un elemento directamente por su número.
-

From 981da7f0692279124626614081a8cb37f90e4510 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 11:38:45 -0300
Subject: [PATCH 02/24] update solution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

arreglé el problema de los espacios.
Por favor tienen que coincidir los números de las líneas con el documento Original.
---
 .../07-map-set/02-filter-anagrams/solution.md        | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
index b22831136..e0c3b67de 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
@@ -1,9 +1,7 @@
-
 Para encontrar todos los anagramas, dividamos cada palabra en letras y las ordenamos. Cuando se clasifican las letras, todos los anagramas son iguales.
 
 Por ejemplo:
 
-
 ```
 nap, pan -> anp
 ear, era, are -> aer
@@ -11,18 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-
 Utilizaremos las variantes ordenadas por letras como claves de Map para almacenar solo un valor por cada clave:
 
-
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-
     // dividir la palabra por letras, ordenarlas y volver a unir
-
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -37,31 +31,26 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-
 La clasificación de letras se realiza mediante la cadena de llamadas en la línea `(*)`.
 
 Por conveniencia la dividimos en múltiples líneas:
 
 ```js
 let sorted = arr[i] // PAN
-
   .toLowerCase() // pan
   .split('') // ['p','a','n']
   .sort() // ['a','n','p']
   .join(''); // anp
 ```
 
-
 Dos palabras diferentes`'PAN'` y `'nap'` reciben la misma forma ordenada por letras `'anp'`.
 
 La siguiente línea pone la palabra en el Map:
 
-
 ```js
 map.set(sorted, word);
 ```
 
-
 Si alguna vez volvemos a encontrar una palabra con la misma forma ordenada por letras, sobrescribiría el valor anterior con la misma clave en Map. Por lo tanto, siempre tendremos como máximo una palabra ordenada por letras.
 
 Al final, `Array.from (map.values())` toma un valor iterativo sobre los valores de Map (no necesitamos claves en el resultado) y devuelve un array de ellos.
@@ -70,7 +59,6 @@ Aquí también podríamos usar un objeto plano en lugar del `Map`, porque las cl
 
 Así es como puede verse la solución:
 
-
 ```js run demo
 function aclean(arr) {
   let obj = {};

From e4ceae7de6b9ba209be182b633381abc5833cdcb Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 11:41:32 -0300
Subject: [PATCH 03/24] update task
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

problemas con la numeración de líneas
---
 1-js/05-data-types/07-map-set/02-filter-anagrams/task.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
index 15622e131..5025b6c97 100644
--- a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
+++ b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
@@ -8,23 +8,19 @@ importance: 4
 
 Por ejemplo:
 
-
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-
 Escriba una función `aclean(arr)` que devuelva un array limpio de anagramas.
 
 Por ejemplo:
 
-
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-
 alert( aclean(arr) ); // "nap,teachers,ear" o "PAN,cheaters,era"
 ```
 

From 78e1bfa3f411189b7e44bb1e4a6a4ea5da787324 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 11:43:12 -0300
Subject: [PATCH 04/24] update solution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

número de líneas
---
 1-js/05-data-types/07-map-set/03-iterable-keys/solution.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
index 9d70bba9a..968c78dfd 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
@@ -1,5 +1,4 @@
 
-
 Eso es porque `map.keys()` devuelve un iterable, pero no un array.
 
 Podemos convertirlo en un array usando `Array.from`:

From e61c2a60d1f5723bd81b18248b42533b6b9e6b65 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 11:48:33 -0300
Subject: [PATCH 05/24] =?UTF-8?q?correcci=C3=B3n=20de=20l=C3=ADneas?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

respetar el número de línea
---
 1-js/05-data-types/07-map-set/03-iterable-keys/task.md | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
index 666fdca55..488284995 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -8,7 +8,6 @@ Nos gustaría obtener un array de `map.keys()` en una variable y luego aplicarle
 
 Pero eso no funciona:
 
-
 ```js run
 let map = new Map();
 
@@ -17,13 +16,9 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-
 // Error: keys.push no es una función
-
 keys.push("more");
 */!*
 ```
 
-
 ¿Por qué? ¿Cómo podemos arreglar el código para que funcione `keys.push`?
-

From 1c79cbe9df42ceed720898ee7f35683257012a12 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 12:27:02 -0300
Subject: [PATCH 06/24] =?UTF-8?q?correcci=C3=B3n=20n=C3=BAmero=20l=C3=ADne?=
 =?UTF-8?q?as?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 1-js/05-data-types/07-map-set/article.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index fa535f76a..d39723879 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -33,7 +33,6 @@ map.set(true, 'bool1'); // un booleano como clave
 
 // recuerda el objeto regular? convertiría las claves en un string
 // Map mantiene el tipo de dato en las claves, por lo que estas dos son diferentes:
-
 alert( map.get(1)   ); // 'num1'
 alert( map.get('1') ); // 'str1'
 
@@ -53,14 +52,12 @@ Por lo tanto, deberíamos usar los métodos de `Map`: `set`, `get`, etc.
 Por ejemplo:
 
 ```js run
-//John es un objeto
 let john = { name: "John" };
 
 // para cada usuario, almacenemos el recuento de visitas
 let visitsCountMap = new Map();
 
-// John es la clave para el Map
-
+// john es la clave para el Map
 visitsCountMap.set(john, 123);
 
 alert( visitsCountMap.get(john) ); // 123
@@ -70,7 +67,6 @@ El uso de objetos como claves es una de las características de `Map` más notab
 
 Intentémoslo:
 
-
 ```js run
 let john = { name: "John" };
 
@@ -78,13 +74,15 @@ let visitsCountObj = {}; // intenta usar un objeto
 
 visitsCountObj[john] = 123; // intenta usar el objeto john como clave
 
+*!*
 // Esto es lo que se escribió!
 alert( visitsCountObj["[object Object]"] ); // 123
+*/!*
 ```
 
-Como `visitsCountObj` es un objeto, convierte todas las claves, como John en string, por lo que tenemos la clave de tipo string `"[objeto Objeto]"`. Definitivamente no es lo que queremos.
+Como `visitsCountObj` es un objeto, convierte todas las claves, como `john` en string, por lo que tenemos la clave de tipo string `"[objeto Objeto]"`. Definitivamente no es lo que queremos.
 
-```smart header="Cómo Map compara las claves" 
+```smart header="Cómo `Map` compara las claves" 
 `Map` utiliza el algoritmo [SameValueZero](https://tc39.es/ecma262/#sec-samevaluezero). Es aproximadamente lo mismo que la igualdad estricta `===`, pero la diferencia es que `NaN` se considera igual a `NaN`. Por lo tanto, `NaN` también se puede usar como clave.
 
 Este algoritmo no se puede cambiar ni personalizar.
@@ -100,7 +98,9 @@ map.set('1', 'str1')
 ```
 ````
 
+
 ## Iteración sobre Map
+
 Para recorrer un `Map`, hay 3 métodos:
 
 - `map.keys()` – devuelve un iterable para las claves.

From 883cd95ef1a0f7c5674f5daa3962dbfe19381acd Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sat, 4 Jul 2020 15:22:43 -0300
Subject: [PATCH 07/24] fixed line numbers

---
 1-js/05-data-types/07-map-set/article.md | 26 ++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index d39723879..d6a04eaf1 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -122,7 +122,6 @@ for (let vegetable of recipeMap.keys()) {
 }
 
 // iterando sobre los valores (precios)
-
 for (let amount of recipeMap.values()) {
   alert(amount); // 500, 350, 50
 }
@@ -132,6 +131,7 @@ for (let entry of recipeMap) { // lo mismo que recipeMap.entries()
   alert(entry); // pepino,500 (etc)
 }
 ```
+
 ```smart header="Se utiliza el orden de inserción."
 La iteración va en el mismo orden en que se insertaron los valores. `Map` conserva este orden, a diferencia de un `Objeto` normal.
 ```
@@ -151,7 +151,6 @@ Cuando se crea un `Map`, podemos pasar un array (u otro iterable) con pares clav
 
 ```js run
 // array de [clave, valor]
-
 let map = new Map([
   ['1',  'str1'],
   [1,    'num1'],
@@ -171,14 +170,18 @@ let obj = {
   age: 30
 };
 
+*!*
 let map = new Map(Object.entries(obj));
+*/!*
 
 alert( map.get('name') ); // John
 ```
 
 Aquí, `Object.entries` devuelve el array de pares clave / valor: [["" name "," John "], [" age ", 30]]. Eso es lo que necesita `Map`.
 
+
 ## Object.fromEntries: Objeto desde Map
+
 Acabamos de ver cómo crear un `Map` a partir de un objeto simple con `Object.entries (obj).`
 
 Existe el método `Object.fromEntries` que hace lo contrario: dado un array de pares [clave, valor], crea un objeto a partir de ellos:
@@ -190,10 +193,11 @@ let prices = Object.fromEntries([
   ['meat', 4]
 ]);
 
-// ahora prices es un objeto = { banana: 1, orange: 2, meat: 4 }
+// ahora prices = { banana: 1, orange: 2, meat: 4 }
 
 alert(prices.orange); // 2
 ```
+
 Podemos usar `Object.fromEntries` para obtener un objeto plano de `Map`.
 
 Ej. almacenamos los datos en un `Map`, pero necesitamos pasarlos a un código de terceros que espera un objeto simple.
@@ -206,7 +210,9 @@ map.set('banana', 1);
 map.set('orange', 2);
 map.set('meat', 4);
 
+*!*
 let obj = Object.fromEntries(map.entries()); // hace un objeto simple
+*/!*
 
 // Hecho!
 // obj = { banana: 1, orange: 2, meat: 4 }
@@ -216,14 +222,15 @@ alert(obj.orange); // 2
 
 Una llamada a `map.entries()` devuelve un array de pares clave / valor, exactamente en el formato correcto para `Object.fromEntries.`
 
-También podríamos acortar la línea 6 del ejemplo anterior:
-
+También podríamos acortar la línea `(*)`:
 ```js
 let obj = Object.fromEntries(map); // omitimos .entries()
 ```
+
 Es lo mismo, porque `Object.fromEntries` espera un objeto iterable como argumento. No necesariamente un array. Y la iteración estándar para el `Map` devuelve los mismos pares clave / valor que `map.entries()`. Entonces obtenemos un objeto simple con las mismas claves / valores que `Map`.
 
 ## Set
+
 `Set` es una colección de tipo especial: "conjunto de valores" (sin claves), donde cada valor puede aparecer solo una vez.
 
 Sus principales métodos son:
@@ -249,7 +256,6 @@ let pete = { name: "Pete" };
 let mary = { name: "Mary" };
 
 // visitas, algunos usuarios lo hacen varias veces
-
 set.add(john);
 set.add(pete);
 set.add(mary);
@@ -263,11 +269,12 @@ for (let user of set) {
   alert(user.name); // John (luego Pete y Mary)
 }
 ```
+
 La alternativa a `Set` podría ser un array de usuarios y el código para verificar si hay duplicados en cada inserción usando [arr.find](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/find). Pero el rendimiento sería mucho peor, porque este método recorre el array completo comprobando cada elemento. `Set` está mucho mejor optimizado internamente para verificaciones de unicidad.
 
 ## Iteración sobre Set
-Podemos recorrer `Set` con `for..of` o usando `forEach`:
 
+Podemos recorrer `Set` con `for..of` o usando `forEach`:
 
 ```js run
 let set = new Set(["oranges", "apples", "bananas"]);
@@ -275,7 +282,6 @@ let set = new Set(["oranges", "apples", "bananas"]);
 for (let value of set) alert(value);
 
 // lo mismo que forEach:
-
 set.forEach((value, valueAgain, set) => {
   alert(value);
 });
@@ -292,9 +298,11 @@ También soporta los mismos métodos que `Map` tiene para los iteradores:
 - `set.entries()` – devuelve un iterable para las entradas `[clave, valor]`, por su compatibilidad con `Map`.
 
 ## Resumen
+
 `Map`: es una colección de valores con clave.
 
 Métodos y propiedades:
+
 - `new Map()` -- crea el mapa.
 - `map.set(clave, valor)` -- almacena el valor para la clave.
 - `map.get(clave)` -- devuelve el valor de la clave: será `undefined` si la `clave` no exite en Map.
@@ -304,12 +312,14 @@ Métodos y propiedades:
 - `map.size` -- retorna el número del elemento actual en el recuento de elementos en el Map.
 
 La diferencia con `Objeto` regular:
+
 - Cualquier clave, los objetos tambien pueden ser claves.
 - Adicionalmente tiene métodos que nos convienen, como la clave `size`.
 
 `Set`: es una colección de valores únicos.
 
 Métodos y propiedades:
+
 - `new Set(iterable)` -- crea el set y, si se proporciona un objeto iterable (generalmente un array), copia los valores del mismo en el set.
 - `set.add(valor)` -- agrega un valor, devuelve el set en sí.
 - `set.delete(valor)` -- elimina el valor, devuelve `true` si `valor` existe al momento de la llamada, si no, devuelve `false`.

From e6f57eaa84e2becb178d491631f8e87fa2e307fc Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:15:10 -0400
Subject: [PATCH 08/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 0f05961f9..78b6209df 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -3,7 +3,6 @@ importance: 5
 ---
 
 
-# Filtrar miembros únicos del array
 
 Permita que `arr` sea un array.
 
@@ -27,4 +26,3 @@ alert( unique(values) ); // Hare, Krishna, :-O
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
 P.D.S. Use `Set` para almacenar valores únicos.
-

From af49a817d48592cc72e183e8ae0886b2ba6a9411 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:15:20 -0400
Subject: [PATCH 09/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 78b6209df..57b8f79da 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-
+# Filtrar miembros únicos del array
 
 Permita que `arr` sea un array.
 

From 459c87492aaf667f876b6f2198a8e66ba0f1974a Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:15:58 -0400
Subject: [PATCH 10/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 57b8f79da..7aa371b5b 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -19,7 +19,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
   "Krishna", "Krishna", "Hare", "Hare", ":-O"
 ];
 
-alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
 

From f6f601666cbe0bfb20c379864dce0ec12833baa4 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:16:06 -0400
Subject: [PATCH 11/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 7aa371b5b..07d0e37c0 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -19,7 +19,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
   "Krishna", "Krishna", "Hare", "Hare", ":-O"
 ];
 
-```
 
 
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.

From 438b4d7179b66c59f40494187416a1c1c3105b33 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:16:19 -0400
Subject: [PATCH 12/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 07d0e37c0..24d04aa72 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -19,7 +19,9 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
   "Krishna", "Krishna", "Hare", "Hare", ":-O"
 ];
 
+P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
+P.D.S. Use `Set` para almacenar valores únicos.
 
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 

From e101acc3bb627509bb732626feffcd1f011f8b93 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:16:35 -0400
Subject: [PATCH 13/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 24d04aa72..1ffd616be 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -23,6 +23,5 @@ P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
 P.D.S. Use `Set` para almacenar valores únicos.
 
-P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
 P.D.S. Use `Set` para almacenar valores únicos.

From f754d71d5c802f7b0c0252911046257baedbe782 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:16:44 -0400
Subject: [PATCH 14/24] Update
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index 1ffd616be..ded04dcb6 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -21,7 +21,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
-P.D.S. Use `Set` para almacenar valores únicos.
 
 
 P.D.S. Use `Set` para almacenar valores únicos.

From 740687fc8dcb15decd8e85815da26a37486783af Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:17:17 -0400
Subject: [PATCH 15/24] Update
 1-js/05-data-types/07-map-set/03-iterable-keys/task.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/03-iterable-keys/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
index 488284995..c40a3f087 100644
--- a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
+++ b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Claves iterables
 
-Nos gustaría obtener un array de `map.keys()` en una variable y luego aplicarle métodos específicos de array, ej. .push.
+Nos gustaría obtener un array de `map.keys()` en una variable y luego aplicarle métodos específicos de array, ej. `.push`.
 
 Pero eso no funciona:
 

From 444e0a5fbbf8da0e23c94b1c4f939272c7ca5cb9 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:17:28 -0400
Subject: [PATCH 16/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index d6a04eaf1..71a5bead8 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -3,7 +3,7 @@
 
 Hasta este momento, hemos aprendido sobre las siguientes estructuras de datos:
 
-- Objetos para almacenar colecciones de claves.
+- Objetos para almacenar colecciones de datos ordenadas mediante una clave.
 - Arrays para almacenar colecciones ordenadas.
 
 Pero eso no es suficiente para la vida real. Por eso también existen Map y Set.

From 669b0ffda5d4f7bb7f3a8aabde5e1bf57bff64e7 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:17:38 -0400
Subject: [PATCH 17/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 71a5bead8..61ca9e341 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -4,7 +4,7 @@
 Hasta este momento, hemos aprendido sobre las siguientes estructuras de datos:
 
 - Objetos para almacenar colecciones de datos ordenadas mediante una clave.
-- Arrays para almacenar colecciones ordenadas.
+- Arrays para almacenar colecciones ordenadas de datos.
 
 Pero eso no es suficiente para la vida real. Por eso también existen Map y Set.
 

From c3f6fc41f36c815c7a3e13fae801306ef8337878 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:17:46 -0400
Subject: [PATCH 18/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 61ca9e341..379079955 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -6,7 +6,7 @@ Hasta este momento, hemos aprendido sobre las siguientes estructuras de datos:
 - Objetos para almacenar colecciones de datos ordenadas mediante una clave.
 - Arrays para almacenar colecciones ordenadas de datos.
 
-Pero eso no es suficiente para la vida real. Por eso también existen Map y Set.
+Pero eso no es suficiente para la vida real. Por eso también existen `Map` y `Set`.
 
 ## Map
 

From b2df4f7c09e0f3ca2e43b6bc33d0604cca65b2f3 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:17:55 -0400
Subject: [PATCH 19/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 379079955..60ea49208 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -10,7 +10,7 @@ Pero eso no es suficiente para la vida real. Por eso también existen `Map` y `S
 
 ## Map
 
-[Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) es una colección de elementos de datos con clave, al igual que un objeto, y valor. Pero la principal diferencia es que Map permite claves de cualquier tipo.
+[Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) es una colección de de datos relacionados, al igual que un `Objeto`. Pero la principal diferencia es que `Map` permite claves de cualquier tipo.
 
 Los métodos y propiedades son:
 

From 2c56508cae3615282feabb73097549de591c6e03 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:18:05 -0400
Subject: [PATCH 20/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 60ea49208..c8876fe70 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -17,7 +17,7 @@ Los métodos y propiedades son:
 - `new Map()` -- crea el mapa.
 - `map.set(clave, valor)` -- almacena el valor para la clave.
 - `map.get(clave)` -- devuelve el valor de la clave: será `undefined` si la `clave` no exite en Map.
-- `map.has(clave)` -- devuelve`true` si la `clave` exite, y `false` si no existe.
+- `map.has(clave)` -- devuelve `true` si la `clave` exite, y `false` si no existe.
 - `map.delete(clave)` -- elimina los valores de la clave.
 - `map.clear()` -- limpia el Map.
 - `map.size` -- retorna el número del elemento actual en el recuento de elementos en el Map.

From 74fee8b7615a47733129656876c23cc625fa3fbe Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:18:13 -0400
Subject: [PATCH 21/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index c8876fe70..b1de8a566 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -83,7 +83,7 @@ alert( visitsCountObj["[object Object]"] ); // 123
 Como `visitsCountObj` es un objeto, convierte todas las claves, como `john` en string, por lo que tenemos la clave de tipo string `"[objeto Objeto]"`. Definitivamente no es lo que queremos.
 
 ```smart header="Cómo `Map` compara las claves" 
-`Map` utiliza el algoritmo [SameValueZero](https://tc39.es/ecma262/#sec-samevaluezero). Es aproximadamente lo mismo que la igualdad estricta `===`, pero la diferencia es que `NaN` se considera igual a `NaN`. Por lo tanto, `NaN` también se puede usar como clave.
+Para probar la equivalencia de claves, `Map` utiliza el algoritmo [SameValueZero](https://tc39.es/ecma262/#sec-samevaluezero). Es aproximadamente lo mismo que la igualdad estricta `===`, pero la diferencia es que `NaN` se considera igual a `NaN`. Por lo tanto, `NaN` también se puede usar como clave.
 
 Este algoritmo no se puede cambiar ni personalizar.
 ```

From 317843569adde17fa0fd63a4a5c6eadc503ac5db Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:18:21 -0400
Subject: [PATCH 22/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index b1de8a566..7c084b949 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -101,7 +101,7 @@ map.set('1', 'str1')
 
 ## Iteración sobre Map
 
-Para recorrer un `Map`, hay 3 métodos:
+Para recorrer un `map`, hay 3 métodos:
 
 - `map.keys()` – devuelve un iterable para las claves.
 - `map.values()` – devuelve un iterable para los valores.

From 3b5c116a7f8200c6cf1a197b84d2f7d213425799 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:18:32 -0400
Subject: [PATCH 23/24] Update 1-js/05-data-types/07-map-set/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/07-map-set/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/05-data-types/07-map-set/article.md b/1-js/05-data-types/07-map-set/article.md
index 7c084b949..6cc72b377 100644
--- a/1-js/05-data-types/07-map-set/article.md
+++ b/1-js/05-data-types/07-map-set/article.md
@@ -20,7 +20,7 @@ Los métodos y propiedades son:
 - `map.has(clave)` -- devuelve `true` si la `clave` exite, y `false` si no existe.
 - `map.delete(clave)` -- elimina los valores de la clave.
 - `map.clear()` -- limpia el Map.
-- `map.size` -- retorna el número del elemento actual en el recuento de elementos en el Map.
+- `map.size` -- retorna el número actual de elementos.
 
 Por ejemplo:
 

From 7dcaca0e559f7433587ba83d0487e2f456183288 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Sat, 4 Jul 2020 19:23:04 -0400
Subject: [PATCH 24/24] Update task.md

---
 1-js/05-data-types/07-map-set/01-array-unique-map/task.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
index ded04dcb6..b212e4a8a 100644
--- a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
+++ b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -19,6 +19,9 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
   "Krishna", "Krishna", "Hare", "Hare", ":-O"
 ];
 
+alert( unique(values) ); // Hare, Krishna, :-O	
+```
+
 P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.