From eaf6a17c8b441c6992fba5d175f4356f3142f1eb Mon Sep 17 00:00:00 2001
From: vplentinax <jc.lerebours.vp@hotmail.com>
Date: Sun, 10 May 2020 20:14:54 -0400
Subject: [PATCH 01/32] iterable

---
 1-js/05-data-types/06-iterable/article.md | 201 +++++++++++-----------
 1 file changed, 102 insertions(+), 99 deletions(-)

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 7f72f5caf..ee9811e9b 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -1,20 +1,19 @@
 
 # Iterables
 
-*Iterable* objects is a generalization of arrays. That's a concept that allows to make any object useable in a `for..of` loop.
+Los objetos *iterables* son una generalización de matrices. Este es un concepto que permite que cualquier objeto pueda ser utilizado en un blucle `for..of`.
 
-Of course, Arrays are iterable. But there are many other built-in objects, that are iterable as well. For instance, Strings are iterable also. As we'll see, many built-in operators and methods rely on them.
-
-If an object represents a collection (list, set) of something, then `for..of` is a great syntax to loop over it, so let's see how to make it work.
+Por supuesto, las matrices o *arrays* son iterables. Pero hay muchos otros objetos integrados, que también lo son. Por ejemplo, las cadenas o *strings* son iterables también. Como veremos, muchos operadores y métodos se basan en la iterabilidad.
 
+Si un objeto representa una colección (lista, conjunto) de algo, entonces el uso de la sintaxis `for..of` es una gran forma de recorrerlo, así que veamos cómo funciona.
 
 ## Symbol.iterator
 
-We can easily grasp the concept of iterables by making one of our own.
+Podemos comprender fácilmente el concepto de iterables por medio de la práctica.
 
-For instance, we have an object, that is not an array, but looks suitable for `for..of`.
+Por ejemplo, tenemos un objeto, que no es una matriz, pero parece adecuado para `for..of`.
 
-Like a `range` object that represents an interval of numbers:
+Como un objeto *`range`* que representa un intervalo de números:
 
 ```js
 let range = {
@@ -22,18 +21,19 @@ let range = {
   to: 5
 };
 
-// We want the for..of to work:
+// Queremos que el for..of funcione de la siguiente manera:
 // for(let num of range) ... num=1,2,3,4,5
 ```
 
-To make the `range` iterable (and thus let `for..of` work) we need to add a method to the object named `Symbol.iterator` (a special built-in symbol just for that).
+Para hacer que el `range` sea iterable (y así permitir que` for..of` funcione) necesitamos agregar un método al objeto llamado `Symbol.iterator` (un símbolo incorporado especial usado solo para realiza esa función, proporcionar iterabilidad).
 
-1. When `for..of` starts, it calls that method once (or errors if not found). The method must return an *iterator* -- an object with the method `next`.
-2. Onward, `for..of` works *only with that returned object*.
-3. When `for..of` wants the next value, it calls `next()` on that object.
-4. The result of `next()` must have the form `{done: Boolean, value: any}`, where `done=true`  means that the iteration is finished, otherwise `value` must be the new value.
+1. Cuando se inicia el `for..of`, éste llama al método  `Symbol.iterator` una vez (o genera un error si no lo encuentra). El método debe devolver un *iterador* --un objeto con el método `next()`.
+2.  En adelante, `for..of` trabaja *solo con ese objeto devuelto*.
+3. Cuando `for..of` quiere el siguiente valor, llama a `next()` en ese objeto.
+4.El resultado de `next()` debe tener la forma `{done: Boolean, value: any}`, donde `done = true` significa que la iteración ha finalizado; de lo contrario,`value` debe ser el nuevo valor.
 
-Here's the full implementation for `range`:
+Aquí está la implementación completa de `range`:
+ 
 
 ```js run
 let range = {
@@ -41,18 +41,18 @@ let range = {
   to: 5
 };
 
-// 1. call to for..of initially calls this
+// 1. Una llamada a for..of inicializa una llamada a esto:
 range[Symbol.iterator] = function() {
 
-  // ...it returns the iterator object:
-  // 2. Onward, for..of works only with this iterator, asking it for next values
+  // ... devuelve el objeto iterador:
+  // 2. En adelante, for..of trabaja solo con este iterador, pidiéndole los siguientes valores
   return {
     current: this.from,
     last: this.to,      
 
-    // 3. next() is called on each iteration by the for..of loop
+    // 3. next () es llamado en cada iteración por el bucle for..of
     next() {
-      // 4. it should return the value as an object {done:.., value :...}
+      // 4. debería devolver el valor como un objeto {done:.., value :...}
       if (this.current <= this.last) {
         return { done: false, value: this.current++ };
       } else {
@@ -62,22 +62,22 @@ range[Symbol.iterator] = function() {
   };
 };
 
-// now it works!
+// ¡Ahora funciona!
 for (let num of range) {
   alert(num); // 1, then 2, 3, 4, 5
 }
 ```
 
-Please note the core feature of iterables: an important separation of concerns:
+Tenga en cuenta la característica principal de los iterables: separación de preocupaciones.
 
-- The `range` itself does not have the `next()` method.
-- Instead, another object, a so-called "iterator" is created by the call to `range[Symbol.iterator]()`, and it handles the whole iteration.
+- El `range` en sí mismo no tiene el método` next() `.
+- En cambio, la llamada a `range[Symbol.iterator]()` crea un llamado "iterador" que maneja toda la iteración.
 
-So, the iterator object is separate from the object it iterates over.
+Por lo tanto, el objeto iterador está separado del objeto sobre el que itera.
 
-Technically, we may merge them and use `range` itself as the iterator to make the code simpler.
+Técnicamente, podemos fusionarlos y usar `range` en sí mismo como iterador para simplificar el código.
 
-Like this:
+Como este:
 
 ```js run
 let range = {
@@ -103,53 +103,54 @@ for (let num of range) {
 }
 ```
 
-Now `range[Symbol.iterator]()` returns the `range` object itself:  it has the necessary `next()` method and remembers the current iteration progress in `this.current`. Shorter? Yes. And sometimes that's fine too.
-
-The downside is that now it's impossible to have two `for..of` loops running over the object simultaneously: they'll share the iteration state, because there's only one iterator -- the object itself. But two parallel for-ofs is a rare thing, doable with some async scenarios.
+Ahora `range[Symbol.iterator]()` devuelve el objeto `range` en sí: tiene el método`next()` necesario y recuerda el progreso de iteración actual en `this.current`. ¿Más corto? Sí. Y a veces eso también está bien.
 
-```smart header="Infinite iterators"
-Infinite iterators are also possible. For instance, the `range` becomes infinite for `range.to = Infinity`. Or we can make an iterable object that generates an infinite sequence of pseudorandom numbers. Also can be useful.
+La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sobre el objeto simultáneamente: compartirán el estado de iteración, porque solo hay un iterador: el objeto en sí. Pero dos for-ofs paralelos es algo raro, factible con algunos escenarios asíncronos.
+ 
+```smart header="Iteradores Infinitos"
+También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` se vuelve infinito así:` range.to = Infinity`. O podemos hacer un objeto iterable que genere una secuencia infinita de números pseudoaleatorios. También puede ser útil.
 
-There are no limitations on `next`, it can return more and more values, that's normal.
+No hay limitaciones en `next`, éste puede retornar muchos valores.
 
-Of course, the `for..of` loop over such an iterable would be endless. But we can always stop it using `break`.
+Por supuesto, el bucle `for..of` sobre un iterativo de este tipo sería interminable. Pero siempre podemos detenerlo usando `break`.
 ```
 
 
-## String is iterable
+## *String* es iterable
 
-Arrays and strings are most widely used built-in iterables.
+Las matrices y cadenas son los iterables integrados más utilizados.
 
-For a string, `for..of` loops over its characters:
+En una cadena o *string*, el bucle `for..of` recorre sus caracteres:
 
 ```js run
 for (let char of "test") {
-  // triggers 4 times: once for each character
-  alert( char ); // t, then e, then s, then t
+  // Se dispara 4 veces: una vez por cada caracter
+  alert( char ); // t, luego e, luego s, luego t
 }
 ```
 
-And it works correctly with surrogate pairs!
+¡Y trabaja correctamente con valores de pares sustitutos (codificación UTF-16)!
 
 ```js run
 let str = '𝒳😂';
 for (let char of str) {
-    alert( char ); // 𝒳, and then 😂
+    alert( char ); // 𝒳, y luego 😂
 }
 ```
 
-## Calling an iterator explicitly
+## Llamar a un iterador explícitamente
 
-Normally, internals of iterables are hidden from the external code. There's a `for..of` loop, that works, that's all it needs to know.
+Normalmente, las partes internas de los iterables están ocultas al código externo. Hay un bucle `for..of`, que funciona, eso es todo lo que necesita saber.
 
-But to understand things a little bit deeper let's see how to create an iterator explicitly.
+Pero para comprender las cosas un poco más en profundidad, veamos cómo crear un iterador explícitamente.
 
-We'll iterate over a string the same way as `for..of`, but with direct calls. This code gets a string iterator and calls it "manually":
+Vamos a iterar sobre una cadena de la misma manera que `for..of`, pero con llamadas directas. Este código obtiene un iterador de cadena y lo llama "manualmente":
+ 
 
 ```js run
-let str = "Hello";
+let str = "Hola";
 
-// does the same as
+// hace lo mismo que
 // for (let char of str) alert(char);
 
 let iterator = str[Symbol.iterator]();
@@ -157,90 +158,90 @@ let iterator = str[Symbol.iterator]();
 while (true) {
   let result = iterator.next();
   if (result.done) break;
-  alert(result.value); // outputs characters one by one
+  alert(result.value); // retorna los caracteres uno por uno
 }
 ```
 
-That is rarely needed, but gives us more control over the process than `for..of`. For instance, we can split the iteration process: iterate a bit, then stop, do something else, and then resume later.
-
-## Iterables and array-likes [#array-like]
-
-There are two official terms that look similar, but are very different. Please make sure you understand them well to avoid the confusion.
+Rara vez se necesita esto, pero nos da más control sobre el proceso que `for..of`. Por ejemplo, podemos dividir el proceso de iteración: iterar un poco, luego parar, hacer otra cosa y luego continuar.
+ 
+## Iterables y array-likes [#array-like]
 
-- *Iterables* are objects that implement the `Symbol.iterator` method, as described above.
-- *Array-likes* are objects that have indexes and `length`, so they look like arrays.
+Hay dos términos oficiales que se parecen, pero son muy diferentes. Asegúrese de comprenderlos bien para evitar confusiones.
+ 
+- *Iterables* son objetos que implementan el método `Symbol.iterator`, como se describió anteriormente.
+- *Array-likes* son objetos que tienen índices y `longitud` o *length*, por lo que se ven como matrices.
 
-Naturally, these properties can combine. For instance, strings are both iterable (`for..of` works on them) and array-like (they have numeric indexes and `length`).
+Naturalmente, estas propiedades pueden combinarse. Por ejemplo, las cadenas son iterables (`for..of` funciona en ellas) y tienen forma de matriz (tienen índices numéricos y` longitud` o *length*).
 
-But an iterable may be not array-like. And vice versa an array-like may be not iterable.
+Pero un iterable puede no tener forma de matriz. Y viceversa, un tipo de matriz puede no ser iterable.
 
-For example, the `range` in the example above is iterable, but not array-like, because it does not have indexed properties and `length`.
+Por ejemplo,`range` en el ejemplo anterior es iterable, pero no como una matriz, porque no tiene propiedades indexadas ni`longitud` o *length*.
 
-And here's the object that is array-like, but not iterable:
+Y aquí está el objeto que tiene forma de matriz, pero no es iterable:
 
 ```js run
-let arrayLike = { // has indexes and length => array-like
-  0: "Hello",
-  1: "World",
+let arrayLike = { // tiene índices y longitud => array-like
+  0: "Hola",
+  1: "Mundo",
   length: 2
 };
 
 *!*
-// Error (no Symbol.iterator)
+// Error (arrayLike no es un iterable)
 for (let item of arrayLike) {}
 */!*
 ```
 
-What do they have in common? Both iterables and array-likes are usually *not arrays*, they don't have `push`, `pop` etc. That's rather inconvenient if we have such an object and want to work with it as with an array.
+¿Qué tienen en común? Tanto los iterables como los array-like generalmente son *no matrices*, no tienen "push", "pop", etc. Eso genera inconvenientes si tenemos un objeto así y queremos trabajar con él como con una matriz.
 
 ## Array.from
 
-There's a universal method [Array.from](mdn:js/Array/from) that brings them together. It takes an iterable or array-like value and makes a "real" `Array` from it. Then we can call array methods on it.
+Existe un método universal [Array.from](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from) que toma un valor iterable o similar a una matriz y crea una matriz ¨real¨ a partir de él. De esta manera podemos llamar y usar métodos que pertenecen a una matriz.
 
-For instance:
+Por ejemplo:
 
 ```js run
 let arrayLike = {
-  0: "Hello",
-  1: "World",
+  0: "Hola",
+  1: "Mundo",
   length: 2
 };
 
 *!*
 let arr = Array.from(arrayLike); // (*)
 */!*
-alert(arr.pop()); // World (method works)
+alert(arr.pop()); // Mundo (el método pop funciona)
 ```
 
-`Array.from` at the line `(*)` takes the object, examines it for being an iterable or array-like, then makes a new array and copies there all items.
+`Array.from` en la línea `(*)` toma el objeto, lo examina por ser iterable o similar a una matriz, luego crea una nueva matriz y copia allí todos los elementos.
 
-The same happens for an iterable:
+Lo mismo sucede para un iterable:
 
 ```js
-// assuming that range is taken from the example above
+// suponiendo que range se toma del ejemplo anterior
 let arr = Array.from(range);
-alert(arr); // 1,2,3,4,5 (array toString conversion works)
+alert(arr); // 1,2,3,4,5 (la conversión de matriz a cadena funciona)
 ```
-
-The full syntax for `Array.from` allows to provide an optional "mapping" function:
+La sintaxis completa para `Array.from` permite proporcionar una función opcional de "mapeo" :
+ 
 ```js
 Array.from(obj[, mapFn, thisArg])
 ```
 
-The second argument `mapFn` should be the function to apply to each element before adding to the array, and `thisArg` allows to set `this` for it.
+El segundo argumento `mapFn` debería ser la función que se aplicará a cada elemento antes de agregarlo a la matriz, y` thisArg` permite establecerlo mediante el `this`.
 
-For instance:
+Por ejemplo:
 
 ```js
-// assuming that range is taken from the example above
+// suponiendo que range se toma del ejemplo anterior
 
-// square each number
+// el cuadrado de cada número
 let arr = Array.from(range, num => num * num);
 
 alert(arr); // 1,4,9,16,25
 ```
 
-Here we use `Array.from` to turn a string into an array of characters:
+Aquí usamos `Array.from` para convertir una cadena en una matriz de caracteres:
 
 ```js run
 let str = '𝒳😂';
@@ -253,14 +254,15 @@ alert(chars[1]); // 😂
 alert(chars.length); // 2
 ```
 
-Unlike `str.split`, it relies on the iterable nature of the string and so, just like `for..of`, correctly works with surrogate pairs.
-
-Technically here it does the same as:
+A diferencia de `str.split`,`Array.from` se basa en la naturaleza iterable de la cadena y, por lo tanto, al igual que`for..of`, funciona correctamente con pares sustitutos.
 
+Técnicamente aquí hace lo mismo que:
+ 
 ```js run
 let str = '𝒳😂';
 
-let chars = []; // Array.from internally does the same loop
+let chars = []; // Array.from internamente hace el mismo bucle
+
 for (let char of str) {
   chars.push(char);
 }
@@ -268,9 +270,9 @@ for (let char of str) {
 alert(chars);
 ```
 
-...But is shorter.    
+... Pero es más corto.    
 
-We can even build surrogate-aware `slice` on it:
+Incluso podemos construir un `segmento` o `slice` compatible con sustitutos en él:
 
 ```js run
 function slice(str, start, end) {
@@ -281,25 +283,26 @@ let str = '𝒳😂𩷶';
 
 alert( slice(str, 1, 3) ); // 😂𩷶
 
-// native method does not support surrogate pairs
-alert( str.slice(1, 3) ); // garbage (two pieces from different surrogate pairs)
+// el método nativo no admite pares sustitutos
+alert( str.slice(1, 3) ); // garbage (dos piezas de diferentes pares sustitutos)
 ```
 
 
-## Summary
-
-Objects that can be used in `for..of` are called *iterable*.
+## Resumen
 
-- Technically, iterables must implement the method named `Symbol.iterator`.
-    - The result of `obj[Symbol.iterator]` is called an *iterator*. It handles the further iteration process.
-    - An iterator must have the method named `next()` that returns an object `{done: Boolean, value: any}`, here `done:true` denotes the iteration end, otherwise the `value` is the next value.
-- The `Symbol.iterator` method is called automatically by `for..of`, but we also can do it directly.
-- Built-in iterables like strings or arrays, also implement `Symbol.iterator`.
-- String iterator knows about surrogate pairs.
+Los objetos que se pueden usar en `for..of` se denominan *iterables*.
 
+- Técnicamente, los iterables deben implementar el método llamado `Symbol.iterator`.
+    - El resultado de `obj[Symbol.iterator]` se llama *iterador*. Maneja el proceso de iteración adicional.
+    - Un iterador debe tener el método llamado `next()` que devuelve un objeto `{done: Boolean, value: any}`, donde `done: true` denota el final de la iteración, de lo contrario, `value` es el siguiente valor.
+- El método `Symbol.iterator` se llama automáticamente por `for..of`, pero también podemos hacerlo directamente.
+- Los iterables integrados, como cadenas o matrices, también implementan `Symbol.iterator`.
+- El iterador de cadena funciona con pares sustitutos.
+ 
 
-Objects that have indexed properties and `length` are called *array-like*. Such objects may also have other properties and methods, but lack the built-in methods of arrays.
+Los objetos que tienen propiedades indexadas y `longitud` o *length* se llaman *array-like*. Dichos objetos también pueden tener otras propiedades y métodos, pero carecen de los métodos integrados de las matrices.
 
-If we look inside the specification -- we'll see that most built-in methods assume that they work with iterables or array-likes instead of "real" arrays, because that's more abstract.
+Si miramos dentro de la especificación, veremos que la mayoría de los métodos incorporados suponen que funcionan con iterables o array-likes en lugar de matrices "reales", porque eso es más abstracto.
 
-`Array.from(obj[, mapFn, thisArg])` makes a real `Array` of an iterable or array-like `obj`, and we can then use array methods on it. The optional arguments `mapFn` and `thisArg` allow us to apply a function to each item.
+`Array.from (obj[, mapFn, thisArg])` crea un verdadero `Array` de un` obj` iterable o array-like, y luego podemos usar métodos de matriz en él. Los argumentos opcionales `mapFn` y` thisArg` nos permiten aplicar una función a cada elemento.
+ 

From 2a8282459dc9eeb12c3421e6a0cb522b1fe2af82 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:15 -0400
Subject: [PATCH 02/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 311f1876b..ac81f6684 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -5,7 +5,7 @@ Los objetos *iterables* son una generalización de matrices. Este es un concepto
 
 Por supuesto, las matrices o *arrays* son iterables. Pero hay muchos otros objetos integrados, que también lo son. Por ejemplo, las cadenas o *strings* son iterables también. Como veremos, muchos operadores y métodos se basan en la iterabilidad.
 
-Si un objeto representa una colección (lista, conjunto) de algo, entonces el uso de la sintaxis `for..of` es una gran forma de recorrerlo, así que veamos cómo funciona.
+Si un objeto no es técnicamente una matriz, pero representa una colección (lista, conjunto) de algo, entonces el uso de la sintaxis `for..of` es una gran forma de recorrerlo, así que veamos cómo funciona.
 
 ## Symbol.iterator
 

From d1f342190ce4481c269e8c411f64249bf1e6ff9b Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:25 -0400
Subject: [PATCH 03/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index ac81f6684..19257b347 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -14,7 +14,7 @@ Podemos comprender fácilmente el concepto de iterables por medio de la práctic
 Por ejemplo, tenemos un objeto, que no es una matriz, pero parece adecuado para `for..of`.
 
 
-Como un objeto *`range`* que representa un intervalo de números:
+Como un objeto `range` que representa un intervalo de números:
 
 ```js
 let range = {

From 2c53a7c2ceda5f0ed3906057d1a3d957e557f845 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:33 -0400
Subject: [PATCH 04/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 19257b347..cbf6efaeb 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -26,7 +26,7 @@ let range = {
 // for(let num of range) ... num=1,2,3,4,5
 ```
 
-Para hacer que el `range` sea iterable (y así permitir que` for..of` funcione) necesitamos agregar un método al objeto llamado `Symbol.iterator` (un símbolo incorporado especial usado solo para realiza esa función, proporcionar iterabilidad).
+Para hacer que el `range` sea iterable (y así permitir que `for..of` funcione) necesitamos agregar un método al objeto llamado `Symbol.iterator` (un símbolo incorporado especial usado solo para realizar esa función, proporcionar iterabilidad).
 
 1. Cuando se inicia el `for..of`, éste llama al método  `Symbol.iterator` una vez (o genera un error si no lo encuentra). El método debe devolver un *iterador* --un objeto con el método `next()`.
 2.  En adelante, `for..of` trabaja *solo con ese objeto devuelto*.

From e8d01b609eb9cd8a04588d3ee49ad59791518f32 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:41 -0400
Subject: [PATCH 05/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index cbf6efaeb..e6e5ac8dd 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -28,7 +28,7 @@ let range = {
 
 Para hacer que el `range` sea iterable (y así permitir que `for..of` funcione) necesitamos agregar un método al objeto llamado `Symbol.iterator` (un símbolo incorporado especial usado solo para realizar esa función, proporcionar iterabilidad).
 
-1. Cuando se inicia el `for..of`, éste llama al método  `Symbol.iterator` una vez (o genera un error si no lo encuentra). El método debe devolver un *iterador* --un objeto con el método `next()`.
+1. Cuando se inicia el `for..of`, éste llama al método `Symbol.iterator` una vez (o genera un error si no lo encuentra). El método debe devolver un *iterador* --un objeto con el método `next()`.
 2.  En adelante, `for..of` trabaja *solo con ese objeto devuelto*.
 3. Cuando `for..of` quiere el siguiente valor, llama a `next()` en ese objeto.
 4.El resultado de `next()` debe tener la forma `{done: Boolean, value: any}`, donde `done = true` significa que la iteración ha finalizado; de lo contrario,`value` debe ser el nuevo valor.

From e293868e84b70a3cb4159d33a0505fe2c14870da Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:49 -0400
Subject: [PATCH 06/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index e6e5ac8dd..07dfabdc7 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -50,7 +50,7 @@ range[Symbol.iterator] = function() {
     current: this.from,
     last: this.to,      
 
-    // 3. next () es llamado en cada iteración por el bucle for..of
+    // 3. next() es llamado en cada iteración por el bucle for..of
     next() {
       // 4. debería devolver el valor como un objeto {done:.., value :...}
       if (this.current <= this.last) {

From e486340d84aece224e06dda83bf791445181b6a6 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:15:59 -0400
Subject: [PATCH 07/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 07dfabdc7..a93962e3f 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -223,7 +223,7 @@ let arr = Array.from(range);
 alert(arr); // 1,2,3,4,5 (la conversión de matriz a cadena funciona)
 ```
 
-La sintaxis completa para `Array.from` permite proporcionar una función opcional de "mapeo" :
+La sintaxis completa para `Array.from` también nos permite proporcionar una función opcional de "mapeo":
 
 ```js
 Array.from(obj[, mapFn, thisArg])

From a33845794d2eb21929b2e1cfc81d95aff52898c3 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:16:10 -0400
Subject: [PATCH 08/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index a93962e3f..5ad6e5a96 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -224,7 +224,6 @@ alert(arr); // 1,2,3,4,5 (la conversión de matriz a cadena funciona)
 ```
 
 La sintaxis completa para `Array.from` también nos permite proporcionar una función opcional de "mapeo":
-
 ```js
 Array.from(obj[, mapFn, thisArg])
 ```

From f9c49f6c143aadcd6e46d3f283c1ca07072aa74b Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:16:19 -0400
Subject: [PATCH 09/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 5ad6e5a96..9c8713d9b 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -228,7 +228,7 @@ La sintaxis completa para `Array.from` también nos permite proporcionar una fun
 Array.from(obj[, mapFn, thisArg])
 ```
 
-El segundo argumento `mapFn` debería ser la función que se aplicará a cada elemento antes de agregarlo a la matriz, y` thisArg` permite establecerlo mediante el `this`.
+El segundo argumento opcional `mapFn` puede ser una función que se aplicará a cada elemento antes de agregarlo a la matriz, y `thisArg` permite establecer el `this` para ello.
 
 Por ejemplo:
 

From aeb56526e4e5a878eed7c3534e79e4db690a390e Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:16:26 -0400
Subject: [PATCH 10/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 9c8713d9b..7aa026608 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -254,7 +254,7 @@ alert(chars[1]); // 😂
 alert(chars.length); // 2
 ```
 
-A diferencia de `str.split`,`Array.from` se basa en la naturaleza iterable de la cadena y, por lo tanto, al igual que`for..of`, funciona correctamente con pares sustitutos.
+A diferencia de `str.split`, `Array.from` se basa en la naturaleza iterable de la cadena y, por lo tanto, al igual que `for..of`, funciona correctamente con pares sustitutos.
 
 Técnicamente aquí hace lo mismo que:
  

From 37f2a5ca7a0f7aadb70f4d13de2e9b174a736b9e Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:16:35 -0400
Subject: [PATCH 11/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 7aa026608..e90812a39 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -304,5 +304,5 @@ Los objetos que tienen propiedades indexadas y `longitud` o *length* se llaman *
 
 Si miramos dentro de la especificación, veremos que la mayoría de los métodos incorporados suponen que funcionan con iterables o array-likes en lugar de matrices "reales", porque eso es más abstracto.
 
-`Array.from (obj[, mapFn, thisArg])` crea un verdadero `Array` de un` obj` iterable o array-like, y luego podemos usar métodos de matriz en él. Los argumentos opcionales `mapFn` y` thisArg` nos permiten aplicar una función a cada elemento.
+`Array.from (obj[, mapFn, thisArg])` crea un verdadero `Array` de un `obj` iterable o array-like, y luego podemos usar métodos de matriz en él. Los argumentos opcionales `mapFn` y `thisArg` nos permiten aplicar una función a cada elemento.
  

From b69ef65069c29755ca5701b57ab15e887217d94f Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:16:50 -0400
Subject: [PATCH 12/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index e90812a39..392c7e459 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -68,7 +68,7 @@ for (let num of range) {
 }
 ```
 
-Tenga en cuenta la característica principal de los iterables: separación de preocupaciones.
+Tenga en cuenta la característica principal de los iterables: separación de conceptos.
 
 - El `range` en sí mismo no tiene el método` next() `.
 - En cambio, la llamada a `range[Symbol.iterator]()` crea un llamado "iterador" que maneja toda la iteración.

From d2abc4db8cd5d552eb49f0b4f409c7f572921948 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:17:08 -0400
Subject: [PATCH 13/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 392c7e459..2e3e314a2 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -70,7 +70,7 @@ for (let num of range) {
 
 Tenga en cuenta la característica principal de los iterables: separación de conceptos.
 
-- El `range` en sí mismo no tiene el método` next() `.
+- El `range` en sí mismo no tiene el método `next()`.
 - En cambio, la llamada a `range[Symbol.iterator]()` crea un llamado "iterador" que maneja toda la iteración.
 
 Por lo tanto, el objeto iterador está separado del objeto sobre el que itera.

From 95769e86511b3aec67f81313dd10909a6b9aadc3 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:17:22 -0400
Subject: [PATCH 14/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 2e3e314a2..b166c6d3b 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -71,7 +71,7 @@ for (let num of range) {
 Tenga en cuenta la característica principal de los iterables: separación de conceptos.
 
 - El `range` en sí mismo no tiene el método `next()`.
-- En cambio, la llamada a `range[Symbol.iterator]()` crea un llamado "iterador" que maneja toda la iteración.
+- En cambio, la llamada a `range[Symbol.iterator]()` crea un otro objeto llamado "iterador", y su `next()` genera valores para la iteración.
 
 Por lo tanto, el objeto iterador está separado del objeto sobre el que itera.
 

From d6c10f74b02746199c8cb80b3958ee496fb16f83 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:17:43 -0400
Subject: [PATCH 15/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index b166c6d3b..2055a26fb 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -77,7 +77,7 @@ Por lo tanto, el objeto iterador está separado del objeto sobre el que itera.
 
 Técnicamente, podemos fusionarlos y usar `range` en sí mismo como iterador para simplificar el código.
 
-Como este:
+De esta manera:
 
 ```js run
 let range = {

From 4050994b0f5ffa2372b3b2b73cf9845d26b57801 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:17:59 -0400
Subject: [PATCH 16/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 2055a26fb..a735f3451 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -103,7 +103,7 @@ for (let num of range) {
 }
 ```
 
-Ahora `range[Symbol.iterator]()` devuelve el objeto `range` en sí: tiene el método`next()` necesario y recuerda el progreso de iteración actual en `this.current`. ¿Más corto? Sí. Y a veces eso también está bien.
+Ahora `range[Symbol.iterator]()` devuelve el objeto `range` en sí: tiene el método `next()` necesario y recuerda el progreso de iteración actual en `this.current`. ¿Más corto? Sí. Y a veces eso también está bien.
 
 La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sobre el objeto simultáneamente: compartirán el estado de iteración, porque solo hay un iterador: el objeto en sí. Pero dos for-ofs paralelos es algo raro, factible con algunos escenarios asíncronos.
  

From 63134c79daa956e55c6024d8ce9e5fcd62cafc36 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:23:37 -0400
Subject: [PATCH 17/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index a735f3451..45b514b3d 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -105,7 +105,7 @@ for (let num of range) {
 
 Ahora `range[Symbol.iterator]()` devuelve el objeto `range` en sí: tiene el método `next()` necesario y recuerda el progreso de iteración actual en `this.current`. ¿Más corto? Sí. Y a veces eso también está bien.
 
-La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sobre el objeto simultáneamente: compartirán el estado de iteración, porque solo hay un iterador: el objeto en sí. Pero dos for-ofs paralelos es algo raro, factible con algunos escenarios asíncronos.
+La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sobre el objeto simultáneamente: compartirán el estado de iteración, porque solo hay un iterador: el objeto en sí. Pero dos for-ofs paralelos es algo raro, incluso en escenarios asíncronos.
  
 ```smart header="Iteradores Infinitos"
 También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` se vuelve infinito así:` range.to = Infinity`. O podemos hacer un objeto iterable que genere una secuencia infinita de números pseudoaleatorios. También puede ser útil.

From 42dde7c5ee2ec676e2d9ecbb1defffa864081a3f Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:23:49 -0400
Subject: [PATCH 18/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 45b514b3d..ad3832fe0 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -108,7 +108,7 @@ Ahora `range[Symbol.iterator]()` devuelve el objeto `range` en sí: tiene el mé
 La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sobre el objeto simultáneamente: compartirán el estado de iteración, porque solo hay un iterador: el objeto en sí. Pero dos for-ofs paralelos es algo raro, incluso en escenarios asíncronos.
  
 ```smart header="Iteradores Infinitos"
-También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` se vuelve infinito así:` range.to = Infinity`. O podemos hacer un objeto iterable que genere una secuencia infinita de números pseudoaleatorios. También puede ser útil.
+También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` se vuelve infinito así: `range.to = Infinity`. O podemos hacer un objeto iterable que genere una secuencia infinita de números pseudoaleatorios. También puede ser útil.
 
 No hay limitaciones en `next`, éste puede retornar muchos valores.
 

From 62315939ec82e32ce1023d02ae44b7b4f489950d Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:24:02 -0400
Subject: [PATCH 19/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index ad3832fe0..ccbc71cb7 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -110,7 +110,7 @@ La desventaja es que ahora es imposible tener dos bucles `for..of` corriendo sob
 ```smart header="Iteradores Infinitos"
 También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` se vuelve infinito así: `range.to = Infinity`. O podemos hacer un objeto iterable que genere una secuencia infinita de números pseudoaleatorios. También puede ser útil.
 
-No hay limitaciones en `next`, éste puede retornar muchos valores.
+No hay limitaciones en `next`, puede devolver más y más valores, eso es normal.
 
 Por supuesto, el bucle `for..of` sobre un iterativo de este tipo sería interminable. Pero siempre podemos detenerlo usando `break`.
 ```

From a61b486b21e8aeadebd0af9778680d5b35efd304 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:24:15 -0400
Subject: [PATCH 20/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index ccbc71cb7..3f26f0888 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -112,7 +112,7 @@ También son posibles los iteradores infinitos. Por ejemplo, el objeto `range` s
 
 No hay limitaciones en `next`, puede devolver más y más valores, eso es normal.
 
-Por supuesto, el bucle `for..of` sobre un iterativo de este tipo sería interminable. Pero siempre podemos detenerlo usando `break`.
+Por supuesto, el bucle `for..of` sobre un iterable de este tipo sería interminable. Pero siempre podemos detenerlo usando `break`.
 ```
 
 ## *String* es iterable

From fe3a79cb1cc65f027b04c719673090c418200fe5 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:24:40 -0400
Subject: [PATCH 21/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 3f26f0888..8cf4b7466 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -139,7 +139,6 @@ for (let char of str) {
 
 ## Llamar a un iterador explícitamente
 
-Normalmente, las partes internas de los iterables están ocultas al código externo. Hay un bucle `for..of`, que funciona, eso es todo lo que necesita saber.
 
 Pero para comprender las cosas un poco más en profundidad, veamos cómo crear un iterador explícitamente.
 

From 2c8d9590055473207e628cb4890f62ead27b0b9c Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:24:59 -0400
Subject: [PATCH 22/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 8cf4b7466..fa29080bd 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -140,7 +140,7 @@ for (let char of str) {
 ## Llamar a un iterador explícitamente
 
 
-Pero para comprender las cosas un poco más en profundidad, veamos cómo crear un iterador explícitamente.
+Vamos a iterar sobre una cadena exactamente de la misma manera que `for..of`, pero con llamadas directas. Este código crea un iterador de cadena y obtiene valores de él "manualmente":
 
 Vamos a iterar sobre una cadena de la misma manera que `for..of`, pero con llamadas directas. Este código obtiene un iterador de cadena y lo llama "manualmente":
  

From 79050323c49a354203f4df98127a6abbebd89d67 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:25:14 -0400
Subject: [PATCH 23/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index fa29080bd..86124f429 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -142,7 +142,6 @@ for (let char of str) {
 
 Vamos a iterar sobre una cadena exactamente de la misma manera que `for..of`, pero con llamadas directas. Este código crea un iterador de cadena y obtiene valores de él "manualmente":
 
-Vamos a iterar sobre una cadena de la misma manera que `for..of`, pero con llamadas directas. Este código obtiene un iterador de cadena y lo llama "manualmente":
  
 ```js run
 let str = "Hola";

From a195f9829b7289935744474435237f282055f104 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:25:31 -0400
Subject: [PATCH 24/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 86124f429..d7d1c90c2 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -159,7 +159,6 @@ while (true) {
   alert(result.value); // retorna los caracteres uno por uno
 }
 ```
-
 Rara vez se necesita esto, pero nos da más control sobre el proceso que `for..of`. Por ejemplo, podemos dividir el proceso de iteración: iterar un poco, luego parar, hacer otra cosa y luego continuar.
  
 ## Iterables y array-likes [#array-like]

From 2cf55acc479998b814c42e4054bc957afaa6abd4 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:25:45 -0400
Subject: [PATCH 25/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index d7d1c90c2..e10c3e45e 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -168,7 +168,7 @@ Hay dos términos oficiales que se parecen, pero son muy diferentes. Asegúrese
 - *Iterables* son objetos que implementan el método `Symbol.iterator`, como se describió anteriormente.
 - *Array-likes* son objetos que tienen índices y `longitud` o *length*, por lo que se ven como matrices.
 
-Naturalmente, estas propiedades pueden combinarse. Por ejemplo, las cadenas son iterables (`for..of` funciona en ellas) y tienen forma de matriz (tienen índices numéricos y` longitud` o *length*).
+Cuando usamos JavaScript para tareas prácticas en el navegador u otros entornos, podemos encontrar objetos que son iterables o array-like, o ambos.
 
 Pero un iterable puede no tener forma de matriz. Y viceversa, un tipo de matriz puede no ser iterable.
 

From f41c3d8dfb436b06edbbcafab0f1bbfdcbed3737 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:26:10 -0400
Subject: [PATCH 26/32] Update 1-js/05-data-types/06-iterable/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 1-js/05-data-types/06-iterable/article.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index e10c3e45e..fa9883dff 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -170,7 +170,9 @@ Hay dos términos oficiales que se parecen, pero son muy diferentes. Asegúrese
 
 Cuando usamos JavaScript para tareas prácticas en el navegador u otros entornos, podemos encontrar objetos que son iterables o array-like, o ambos.
 
-Pero un iterable puede no tener forma de matriz. Y viceversa, un tipo de matriz puede no ser iterable.
+Por ejemplo, las cadenas son iterables (`for..of` funciona en ellas) y array-like (tienen índices numéricos y `length`).
+
+Pero un iterable puede no ser array-like. Y viceversa, un array-like puede no ser iterable.
 
 Por ejemplo,`range` en el ejemplo anterior es iterable, pero no como una matriz, porque no tiene propiedades indexadas ni`longitud` o *length*.
 

From 66c34e0b3e4a6b8a5d6c1b06747af662af6799cf Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:26:24 -0400
Subject: [PATCH 27/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index fa9883dff..ecfd18a98 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -174,7 +174,8 @@ Por ejemplo, las cadenas son iterables (`for..of` funciona en ellas) y array-lik
 
 Pero un iterable puede no ser array-like. Y viceversa, un array-like puede no ser iterable.
 
-Por ejemplo,`range` en el ejemplo anterior es iterable, pero no como una matriz, porque no tiene propiedades indexadas ni`longitud` o *length*.
+
+Por ejemplo, `range` en el ejemplo anterior es iterable, pero no array-like, porque no tiene propiedades indexadas ni `longitud` o *length*.
 
 Y aquí está el objeto que tiene forma de matriz, pero no es iterable:
 

From 9423df1211c21eec7d81b7d03817957de4ace1b4 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:26:39 -0400
Subject: [PATCH 28/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index ecfd18a98..0be39f908 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -177,6 +177,7 @@ Pero un iterable puede no ser array-like. Y viceversa, un array-like puede no se
 
 Por ejemplo, `range` en el ejemplo anterior es iterable, pero no array-like, porque no tiene propiedades indexadas ni `longitud` o *length*.
 
+
 Y aquí está el objeto que tiene forma de matriz, pero no es iterable:
 
 ```js run

From a89b9c39c284732762c453f1c9fc11db0cb6494b Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:26:59 -0400
Subject: [PATCH 29/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 0be39f908..516ff6c49 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -188,7 +188,7 @@ let arrayLike = { // tiene índices y longitud => array-like
 };
 
 *!*
-// Error (arrayLike no es un iterable)
+// Error (sin Symbol.iterator)
 for (let item of arrayLike) {}
 */!*
 ```

From 65a463151cdf26ff443ff289185a9dea66b71c75 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:27:16 -0400
Subject: [PATCH 30/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 516ff6c49..8eaafbe37 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -193,7 +193,7 @@ for (let item of arrayLike) {}
 */!*
 ```
 
-¿Qué tienen en común? Tanto los iterables como los array-like generalmente son *no matrices*, no tienen "push", "pop", etc. Eso genera inconvenientes si tenemos un objeto así y queremos trabajar con él como con una matriz.
+Tanto los iterables como los array-like generalmente no son *matrices*, no tienen "push", "pop", etc. Eso es bastante inconveniente si tenemos un objeto de este tipo y queremos trabajar con él como con una matriz. P.ej. nos gustaría trabajar con `range` utilizando métodos de matriz. ¿Cómo lograr eso?
 
 ## Array.from
 

From 2639caad460be60a0e7bd34e859fb7a871751ff6 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:27:37 -0400
Subject: [PATCH 31/32] Update 1-js/05-data-types/06-iterable/article.md

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

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index 8eaafbe37..cd095c262 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -197,7 +197,7 @@ Tanto los iterables como los array-like generalmente no son *matrices*, no tiene
 
 ## Array.from
 
-Existe un método universal [Array.from](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from) que toma un valor iterable o similar a una matriz y crea una matriz ¨real¨ a partir de él. De esta manera podemos llamar y usar métodos que pertenecen a una matriz.
+Existe un método universal [Array.from](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from) que toma un valor iterable o similar a una matriz y crea un `Array` ¨real¨ a partir de él. De esta manera podemos llamar y usar métodos que pertenecen a una matriz.
 
 Por ejemplo:
 

From 36b0d0876b063fb9a9c30e3e04b18a26c75f23d1 Mon Sep 17 00:00:00 2001
From: Valentina VP <34555644+vplentinax@users.noreply.github.com>
Date: Mon, 22 Jun 2020 16:33:45 -0400
Subject: [PATCH 32/32] Update article.md

---
 1-js/05-data-types/06-iterable/article.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index cd095c262..f0637fa2b 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -139,6 +139,7 @@ for (let char of str) {
 
 ## Llamar a un iterador explícitamente
 
+Para una comprensión más profunda, veamos cómo usar un iterador explícitamente.
 
 Vamos a iterar sobre una cadena exactamente de la misma manera que `for..of`, pero con llamadas directas. Este código crea un iterador de cadena y obtiene valores de él "manualmente":