Propiedades y metodos del objeto map

taller-2/for-in.md

@@ -0,0 +1,24 @@
+# Ciclo for in
+
+La sentencia _for in_ realiza un bucle a través de las llaves de un objecto _{nombre: 'juan', edad: 22, comunidad:'ibaguejs' }_ donde 
+nombre es la llave y el _'juan'_ es el valor
+
+
+un bucle _for in_ se parece a lo siguiente:
+
+```js
+var persona = {nombre: 'juan', edad: 22, comunidad:'ibaguejs' }
+for (var llave in persona) {
+   console.log(llave);
+   //para acceder al valor de la llave sobre el objecto
+   console.log(persona[llave])
+}
+```
+
+Recuerda que la sentencia _for in_ solo funciona sobre objetos 
+
+## Ejercicio
+
+Crea un objeto para iterar sobre sus llaves y utiliza `console.log()` para imprimir en la terminal la llave y el valor que tiene es llave en el objeto
+
+

taller-2/for-of.md

@@ -0,0 +1,19 @@
+# Ciclo for of
+
+La sentencia _for of_ realiza un bucle a través de los valores de una lista y/o arreglo
+
+un bucle _for of_ se parece a lo siguiente:
+
+```js
+var listaDeNumeros = [1, 2, 3, 4, 5]
+for (var numero of listaDeNumeros) {
+   console.log(numero);
+}
+```
+
+En la Declaracion anterior se crea un arreglo y/o lista de numeros, en la sentencia, al interior de los parentesis se declara una variable
+numero donde almacenará el valor de cada item de la lista y/o arreglo 
+
+## Ejercicio
+
+Declara una lista y/o arreglo de numeros y dentro de la sentencia de _for_ determina si el numero es par o impar, utiliza `console.log()` para imprimir en la terminal si el numero es par o impar

taller-2/for.md

@@ -0,0 +1,18 @@
+# Ciclo for
+
+La sentencia _for_ crea un bucle que consiste en tres expresiones opcionales, encerradas entre paréntesis y separadas por punto y coma, seguidas de una sentencia (normalmente una sentencia de bloqueo) que se ejecutará en el bucle.
+
+un bucle _for_ se parece a lo siguiente:
+
+```js
+for (let contador = 0; contador < 9; contador++) {
+   console.log(contador);
+}
+```
+
+La declaración anterior comienza declarando la variable contador e inicializándola con el valor 0. Comprueba que contador es menor que nueve (9), realiza las dos declaraciones sucesivas, e incrementa el contador en 1 después de cada paso por el bucle.
+
+## Ejercicio
+
+Declara un _for_ donde realize 10 veces el bucle pero inicializando el contador en 1, dentro del bucle utiliza `console.log()` para imprimir en la terminal el valor numerico
+

taller-3/Map-clear.md

@@ -0,0 +1,22 @@
+# Metodo clear
+
+Elimina todos los pares llave-valor del objeto `Map`.
+
+## Ejemplo
+```js
+  const map = new Map()
+  map.set('nombre', 'ibaguejs')
+  map.set('edad', 1)
+  map.set('es grandioso ibaguejs', true)
+
+  console.log(map)
+
+  //limpiamos y/o borramos los pares de llave valor del mapa
+  map.clear()
+
+  console.log(map)
+``` 
+
+## Ejercicio
+
+Crea un objecto de tipo `Map` con n pares de llave-valor, luego limpiar el objeto map 

taller-3/Map-delete.md

@@ -0,0 +1,29 @@
+# Metodo delete
+
+Devuelve `true` si un elemento en el objeto `Map` existió y se eliminó, o `false` si el elemento no existe.
+
+## Ejercio
+
+Crear un objeto de tipo `Map`, agrega pares de llave-valor de los siguientes datos
+ - nombre : julian
+ - apellido : morales 
+ - edad: 22
+ - trabaja: true
+
+en el objeto map elimina los pares de llave valor e imprime en un `console.log` si el par de llave valor fue eliminado
+
+### ejemplo
+```js
+  const map = new Map()
+  map.set('comunidad', 'ibaguejs')
+  console.log(map.delete('comunidad'))
+  // el resultado esperado es: true
+  // true indica que fue removido exitosamente
+
+  console.log(map.has('cominudad'))
+  // false indica que no existe ya en el objecto map
+
+  console.log(map.delete('comunidad'))
+  // el resultado es false, dado que no existe no se puede eliminar
+
+```

taller-3/Map-entries.md

@@ -0,0 +1,30 @@
+# Metodo entries
+
+El método `entries()` devuelve un nuevo objeto Iterator que contiene los [key, value]pares para cada elemento en el objeto `Map` en orden de inserción.
+
+## Iterador en 5 minutos
+
+En JavaScript un iterador es un objeto que define una secuencia y potencialmente un valor de retorno a su terminación.
+
+Específicamente, un iterador es cualquier objeto que implemente el protocolo Iterator teniendo un método next() que devuelva un objeto con dos propiedades:
+
+ - value: El siguiente valor en la secuencia de iteración.
+ - done: Es un valor booleano si es `true` significa que ya ha finalizado, en caso contrario aun no ha terminado
+
+## Ejemplo
+
+```js
+  const map1 = new Map();
+
+  map1.set('0', 'cero en string');
+  map1.set(1, 'uno en numerico');
+
+  //almacenamos el objeto iterador 
+  const iterator1 = map1.entries();
+
+  console.log(iterator1.next().value);
+  // salida esperada: ["0", "cero "]
+
+  console.log(iterator1.next().value);
+  // salida esperada: [1, "uno en numerico"]
+```

taller-3/Map-forEach.md

@@ -0,0 +1,26 @@
+# Metodo forEach
+
+El método `forEach()` ejecuta una función proporcionada una vez por cada par llave-valor en el objeto `Map`, en el orden de inserción.
+
+## Ejemplo
+```js
+  // esta funcion imprimira los pares llave-valor
+
+  const map = new Map()
+
+  map.set('uno', 1)
+  map.set('dos', 2)
+  map.set('tres', 3)
+
+  function logMapElements(value, key) {
+    console.log(`llave ${key}: valor ${value}`);
+  }
+
+  // el metodo for each recibe como para metro la funcion logMapElements y por cada par llave-valor que se encuentre en el map
+  map.forEach(logMapElements);
+
+  // salida esperada: "llave uno : valor 1"
+  // expected output: "llave dos : valor 2"
+  // expected output: "llave tres : valor 3"
+```
+

taller-3/Map-get.md

@@ -0,0 +1,32 @@
+# Metodo get
+
+Devuelve el valor asociado a la key, o `undefined` si no se encuentra en el mapa.
+
+```js 
+  // crear un nuevo mapa  
+  const map = new Map()
+  // asignar un nuevo par llave-valor
+  map.set('nombre', 'juanjs')
+  // obtener ese nuevo valor
+  console.log(map.get('nombre'))
+  //obtener un valor con una llave que no existe en el mapa
+  console.log(map.get('edad'))
+  //como resultado dara undefined
+```
+
+## Ejercicio 
+crea el siguiente objecto `Map` y determina con el operador _typeof_ que tipo de dato esta almacenando la llave
+
+```js
+  const mapa = new Map()
+  map.set('nombre', 'ibagues')
+  map.set('edad', 1)
+  map.set('es grandioso ibaguejs', true)
+  map.set('miembro', { patrocinadores: 'SENA', lugar: 'Picaleña' })
+```
+
+
+
+
+
+

taller-3/Map-has.md

@@ -0,0 +1,19 @@
+# Metodo has
+
+El método `has()` devuelve un valor booleano (verdader o false, true o false) que indica si un elemento con la clave especificada existe o no.
+
+```js
+  const map = new Map()
+  map.set('nombre', 'julian')
+
+  console.log(map.has('nombre'))
+```
+
+## Ejercicio
+
+Crea un objeto map, agrega par llave valor, con los siguientes valores
+
+ - lenguaje1 : javascript
+ - lenguaje2 : java
+
+verifica que que exista el par llave-valor llamado lenguaje3, y debe tener el valor golang, si no existe agregarlo y verificar nuevamente que existe

taller-3/Map-keys.md

@@ -0,0 +1,31 @@
+# Metodo keys
+
+El método `keys()` devuelve un nuevo objeto `Iterator` que contiene las claves para cada elemento en el objeto `Map` en orden de inserción.
+
+## Iterador en 5 minutos
+
+En JavaScript un iterador es un objeto que define una secuencia y potencialmente un valor de retorno a su terminación.
+
+Específicamente, un iterador es cualquier objeto que implemente el protocolo Iterator teniendo un método next() que devuelva un objeto con dos propiedades:
+
+ - value: El siguiente valor en la secuencia de iteración.
+ - done: Es un valor booleano si es `true` significa que ya ha finalizado, en caso contrario aun no ha terminado
+
+
+## Ejemplo
+
+```js 
+  const map1 = new Map();
+
+  map1.set('0', 'cero en string');
+  map1.set(1, 'uno en numerico');
+
+  //almacenamos el objeto iterador
+  const iterator1 = map1.keys();
+
+  console.log(iterator1.next().value);
+  // expected output: "0"
+
+  console.log(iterator1.next().value);
+  // expected output: 1
+```

taller-3/Map-set.md

@@ -0,0 +1,27 @@
+# Metodo set
+
+Establece un valor para `key` en el objecto `Map`. si la `key` no existe se agrega, si existe se actualiza
+
+```js 
+  const map = new Map();
+  //agrega un nuevo par llave-valor
+  map.set('mensaje', 'ibaguejs es genial');
+  //actualizamos esa key
+  map.set('mensaje', 'yo amo ibaguejs');
+```
+
+## Ejercicio
+crea un objeto de tipo `Map` y agrega pares de llave-valor usando los siguientes tipos de datos, el valor puede ser cualquiera
+  - string : `'texto'`
+  - booleano : `true`  - `false`
+  - numerico : 0 
+  - Objecto : `{ mensaje:'soy un objeto' }`
+
+  ## Ejemplo
+  ```js
+    const map = new Map()
+    //con un dato tipo texto - string
+    map.set('nombre', 'juanjs');
+
+    console.log(map)
+  ```

taller-3/Map-size.md

@@ -0,0 +1,17 @@
+# Propiedad size
+
+Devuelve un valor numerico indicando la longitud de pares llave-valor en el Objecto `Map`
+
+```js 
+//crear un nuevo mapa y almacenarlo en una variable
+const map = new Map()
+
+//correr el codigo en consola
+console.log(map.size)
+
+//el resultado deberia ser 0
+
+```
+
+el valor de la propiedad `size` es 0 dado que el objecto `Map` no cotiene ningun pares de llave-valor
+

taller-3/Map-values.md

@@ -0,0 +1,30 @@
+# Metodo values
+
+El método `values()` devuelve un nuevo objeto `Iterator` que contiene los valores para cada elemento en el objeto `Map` en orden de inserción.
+
+## Iterador en 5 minutos
+
+En JavaScript un iterador es un objeto que define una secuencia y potencialmente un valor de retorno a su terminación.
+
+Específicamente, un iterador es cualquier objeto que implemente el protocolo Iterator teniendo un método next() que devuelva un objeto con dos propiedades:
+
+ - value: El siguiente valor en la secuencia de iteración.
+ - done: Es un valor booleano si es `true` significa que ya ha finalizado, en caso contrario aun no ha terminado
+
+
+## Ejemplo
+```js
+  const map1 = new Map();
+
+  map1.set('0', 'cero en string');
+  map1.set(1, 'uno en numerico');
+
+  //alamacenamos el objeto iterador
+  const iterator1 = map1.values();
+
+  console.log(iterator1.next().value);
+  // expected output: "foo"
+
+  console.log(iterator1.next().value);
+  // expected output: "bar"
+```

taller-3/Map.md

@@ -0,0 +1,17 @@
+# Objecto Map, una estructura de datos compleja
+
+**Definicion**
+El Objecto _Map_ es una estructura y/o colección de datos que contiene pares de llave-valor igual que un _Objecto_ pero recuerda el orden de inserción original de las llaves. Una principal caracteristica que tienen los Objectos _Map_, permiten llaves de cualquier tipo (tanto como objetos como valoresp primitivos).
+
+**Los métodos y propiedades son:**
+  - `new Map()`
+  - `map.size`
+  - `map.set(key, value)`
+  - `map.get(key)`
+  - `map.clear()`
+  - `map.has(key)`
+  - `map.delete(key)`
+  - `map.entries()`
+  - `map.forEach()`
+  - `map.keys()`
+  - `map.values()`