From 1e65c04841729b7cb3610c969b41c94540b6976b Mon Sep 17 00:00:00 2001
From: danilobrinu <ddbn.c2@gmail.com>
Date: Thu, 8 Oct 2020 20:45:01 -0500
Subject: [PATCH 01/53] Update article

---
 .../17-regexp-methods/article.md              | 211 +++++++++---------
 1 file changed, 106 insertions(+), 105 deletions(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index e4044361f..920105723 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -1,32 +1,32 @@
-# Methods of RegExp and String
+# Métodos de RegExp y String
 
-In this article we'll cover various methods that work with regexps in-depth.
+En este artículo vamos a abordar varios métodos que funcionan con expresiones regulares a fondo.
 
 ## str.match(regexp)
 
-The method `str.match(regexp)` finds matches for `regexp` in the string `str`.
+El método `str.match(regexp)` encuentra coincidencias para las expresiones regulares (`regexp`) en la cadena (`str`).
 
-It has 3 modes:
+Tiene 3 modos:
 
-1. If the `regexp` doesn't have flag `pattern:g`, then it returns the first match as an array with capturing groups and properties `index` (position of the match), `input` (input string, equals `str`):
+1. Si la expresión regular (`regexp`) no tiene la bandera `pattern:g`, retorna una lista con los grupos capturados y las propiedades `index` (posición de la coincidencia), `input` (cadena de entrada, igual a `str`):
 
     ```js run
     let str = "I love JavaScript";
 
     let result = str.match(/Java(Script)/);
 
-    alert( result[0] );     // JavaScript (full match)
-    alert( result[1] );     // Script (first capturing group)
+    alert( result[0] );     // JavaScript (toda la coincidencia)
+    alert( result[1] );     // Script (primer grupo capturado)
     alert( result.length ); // 2
 
     // Additional information:
     alert( result.index );  // 0 (match position)
-    alert( result.input );  // I love JavaScript (source string)
+    alert( result.input );  // I love JavaScript (cadena de entrada)
     ```
 
-2. If the `regexp` has flag `pattern:g`, then it returns an array of all matches as strings, without capturing groups and other details.
+2. Si la expresión regular (`regexp`) tiene la bandera `pattern:g`, retorna una lista de todas las coincidencias como cadenas, sin capturar grupos y otros detalles.
     ```js run
-    let str = "I love JavaScript";
+    let str = "Yo amo JavaScript";
 
     let result = str.match(/Java(Script)/g);
 
@@ -34,12 +34,12 @@ It has 3 modes:
     alert( result.length ); // 1
     ```
 
-3. If there are no matches, no matter if there's flag `pattern:g` or not, `null` is returned.
+3. Si no hay coincidencias, no importa si tiene la bandera `pattern:g` o no, `null` es retornado.
 
-    That's an important nuance. If there are no matches, we don't get an empty array, but `null`. It's easy to make a mistake forgetting about it, e.g.:
+    Esto es algo mmuy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidandolo, ej.:
 
     ```js run
-    let str = "I love JavaScript";
+    let str = "Yo amo JavaScript";
 
     let result = str.match(/HTML/);
 
@@ -47,7 +47,7 @@ It has 3 modes:
     alert(result.length); // Error: Cannot read property 'length' of null
     ```
 
-    If we want the result to be an array, we can write like this:
+    Si queremos que el resultado sea una lista, podemos escribirlo así:
 
     ```js
     let result = str.match(regexp) || [];
@@ -57,17 +57,17 @@ It has 3 modes:
 
 [recent browser="new"]
 
-The method `str.matchAll(regexp)` is a "newer, improved" variant of `str.match`.
+El método `str.matchAll(regexp)` es una variante ("nueva y mejorada") de `str.match`.
 
-It's used mainly to search for all matches with all groups.
+Es usado principalmente para buscar por todas las coincidencias con todo todos los grupos.
 
-There are 3 differences from `match`:
+Hay 3 diferencias con `match`:
 
-1. It returns an iterable object with matches instead of an array. We can make a regular array from it using `Array.from`.
-2. Every match is returned as an array with capturing groups (the same format as `str.match` without flag `pattern:g`).
-3. If there are no results, it returns not `null`, but an empty iterable object.
+1. Retorna un objecto iterable con las coincidencias en lugar de una lista. Podemos convertirlo en una lista usando el método `Array.from`.
+2. Cada coincidencia es retornada como una lista con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
+3. Si no hay resultados, no retorna `null`, pero si un objecto iterable vacío.
 
-Usage example:
+Ejemplo de uso:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -75,9 +75,9 @@ let regexp = /<(.*?)>/g;
 
 let matchAll = str.matchAll(regexp);
 
-alert(matchAll); // [object RegExp String Iterator], not array, but an iterable
+alert(matchAll); // [object RegExp String Iterator], no es una lista, pero si un objeto iterable
 
-matchAll = Array.from(matchAll); // array now
+matchAll = Array.from(matchAll); // ahora es una lista
 
 let firstMatch = matchAll[0];
 alert( firstMatch[0] );  // <h1>
@@ -86,97 +86,97 @@ alert( firstMatch.index );  // 0
 alert( firstMatch.input );  // <h1>Hello, world!</h1>
 ```
 
-If we use `for..of` to loop over `matchAll` matches, then we don't need `Array.from` any more.
+Si usamos `for..of` para iterar todas las coincidencias de `matchAll`, no necesitamos `Array.from`.
 
 ## str.split(regexp|substr, limit)
 
-Splits the string using the regexp (or a substring) as a delimiter.
+Divide la cadena usando la expresión regular (o una sub-cadena) como delimitador.
 
-We can use `split` with strings, like this:
+Podemos usar `split` con cadenas, así:
 
 ```js run
-alert('12-34-56'.split('-')) // array of [12, 34, 56]
+alert('12-34-56'.split('-')) // lista de [12, 34, 56]
 ```
 
-But we can split by a regular expression, the same way:
+O también dividir una cadena usando una expresión regular de la misma forma:
 
 ```js run
-alert('12, 34, 56'.split(/,\s*/)) // array of [12, 34, 56]
+alert('12, 34, 56'.split(/,\s*/)) // lista de [12, 34, 56]
 ```
 
 ## str.search(regexp)
 
-The method `str.search(regexp)` returns the position of the first match or `-1` if none found:
+El método `str.search(regexp)` retorna la posición de la primera coincidencia o `-1` si no encuentra nada:
 
 ```js run
 let str = "A drop of ink may make a million think";
 
-alert( str.search( /ink/i ) ); // 10 (first match position)
+alert( str.search( /ink/i ) ); // 10 (posición de la primera coincidencia)
 ```
 
-**The important limitation: `search` only finds the first match.**
+**Limitación importante: solo `search` encuentra la primera coincidencia.**
 
-If we need positions of further matches, we should use other means, such as finding them all with `str.matchAll(regexp)`.
+Si necesitamos las posiciones de las demás coincidencias, deberíamos usar otros medios, como encontrar todos con `str.matchAll(regexp)`.
 
 ## str.replace(str|regexp, str|func)
 
-This is a generic method for searching and replacing, one of most useful ones. The swiss army knife for searching and replacing.  
+Este es un método genérico para buscar y reemplazar, uno de los más útiles. La navaja suiza para buscar y reemplazar.  
 
-We can use it without regexps, to search and replace a substring:
+Podemos usarlo sin expresiones regular, para buscar y reemplazar una sub-cadena:
 
 ```js run
-// replace a dash by a colon
+// reemplazar guión por dos puntos
 alert('12-34-56'.replace("-", ":")) // 12:34-56
 ```
 
-There's a pitfall though.
+Sin embargo hay una trampa:
 
-**When the first argument of `replace` is a string, it only replaces the first match.**
+**Cuando el primer argumento de `replace` es una cadena, solo reemplaza la primera coincidencia.**
 
-You can see that in the example above: only the first `"-"` is replaced by `":"`.
+Puedes ver eso en el ejemplo anterior: solo el primer `"-"` es reemplazado por `":"`.
 
-To find all hyphens, we need to use not the string `"-"`, but a regexp `pattern:/-/g`, with the obligatory `pattern:g` flag:
+Para encontrar todos los guiones, no necesitamos usar un cadena `"-"` sino una expresión regular `pattern:/-/g` con la bandera `pattern:g` obligatoria:
 
 ```js run
-// replace all dashes by a colon
+// reemplazar todos los guiones por dos puntos
 alert( '12-34-56'.replace( *!*/-/g*/!*, ":" ) )  // 12:34:56
 ```
 
-The second argument is a replacement string. We can use special character in it:
+El segundo argumento es la cadena de reemplazo. Podemos usar caracteres especiales:
 
-| Symbols | Action in the replacement string |
+| Símbolos | Acción en la cadena de reemplazo |
 |--------|--------|
-|`$&`|inserts the whole match|
-|<code>$&#096;</code>|inserts a part of the string before the match|
-|`$'`|inserts a part of the string after the match|
-|`$n`|if `n` is a 1-2 digit number, inserts the contents of n-th capturing group, for details see [](info:regexp-groups)|
-|`$<name>`|inserts the contents of the parentheses with the given `name`, for details see [](info:regexp-groups)|
-|`$$`|inserts character `$` |
+|`$&`|inserta toda la coincidencia|
+|<code>$&#096;</code>|inserta una parte de la cadena antes de la coincidencia|
+|`$'`|inserta una parte de la cadena después de la coincidencia|
+|`$n`|si `n` es un 1-2 dígito númerico, inserta el contenido del enésimo grupo capturado, para más detalles ver [](info:regexp-groups)|
+|`$<nombre>`|inserta el contenido de los paréntesis con el `nombre` dado, para más detalles ver [](info:regexp-groups)|
+|`$$`|inserta el carácter `$` |
 
-For instance:
+Por ejemplo:
 
 ```js run
 let str = "John Smith";
 
-// swap first and last name
+// intercambiar el nombre con el apellido
 alert(str.replace(/(john) (smith)/i, '$2, $1')) // Smith, John
 ```
 
-**For situations that require "smart" replacements, the second argument can be a function.**
+**Para situaciones que requieran reemplazos "inteligentes", el segundo argumento puede ser una función.**
 
-It will be called for each match, and the returned value will be inserted as a replacement.
+Puede ser llamado por cada coincidencia y el valor retornado puede ser insertado como un reemplazo.
 
-The function is called with arguments `func(match, p1, p2, ..., pn, offset, input, groups)`:
+La función es llamada con los siguientes argumentos `func(match, p1, p2, ..., pn, offset, input, groups)`:
 
-1. `match` -- the match,
-2. `p1, p2, ..., pn` -- contents of capturing groups (if there are any),
-3. `offset` -- position of the match,
-4. `input` -- the source string,
-5. `groups` -- an object with named groups.
+1. `match` -- la coincidencia,
+2. `p1, p2, ..., pn` -- contenido de los grupos capturados (si hay alguno),
+3. `offset` -- posición de la coincidencia,
+4. `input` -- la cadena de entrada,
+5. `groups` -- un objecto con los grupos nombrados.
 
-If there are no parentheses in the regexp, then there are only 3 arguments: `func(str, offset, input)`.
+Si hay paréntesis en la expresión regular, entonces solo son 3 argumentos: `func(str, offset, input)`.
 
-For example, let's uppercase all matches:
+Por ejemplo, hacer mayúsculas todas las coincidencias:
 
 ```js run
 let str = "html and css";
@@ -186,13 +186,13 @@ let result = str.replace(/html|css/gi, str => str.toUpperCase());
 alert(result); // HTML and CSS
 ```
 
-Replace each match by its position in the string:
+Reemplazar cada coincidencia por su posición en la cadena:
 
 ```js run
 alert("Ho-Ho-ho".replace(/ho/gi, (match, offset) => offset)); // 0-3-6
 ```
 
-In the example below there are two parentheses, so the replacement function is called with 5 arguments: the first is the full match, then 2 parentheses, and after it (not used in the example) the match position and the source string:
+En el ejemplo anterior hay dos paréntesis, entonces la función de reemplazo es llamada con 5 argumentos: el primero es toda la coincidencia, luego dos paréntesis, y después (no usado en el ejemplo) la posición de la coincidencia y la cadena de entrada:
 
 ```js run
 let str = "John Smith";
@@ -202,7 +202,7 @@ let result = str.replace(/(\w+) (\w+)/, (match, name, surname) => `${surname}, $
 alert(result); // Smith, John
 ```
 
-If there are many groups, it's convenient to use rest parameters to access them:
+Si hay muchos grupos, es conveniente usar parámetros rest para acceder a ellos:
 
 ```js run
 let str = "John Smith";
@@ -212,7 +212,7 @@ let result = str.replace(/(\w+) (\w+)/, (...match) => `${match[2]}, ${match[1]}`
 alert(result); // Smith, John
 ```
 
-Or, if we're using named groups, then `groups` object with them is always the last, so we can obtain it like this:
+O, si estamos usando grupos nombrados, entonces el objecto `groups` con ellos es siempre el último, por lo que podemos obtenerlos así:
 
 ```js run
 let str = "John Smith";
@@ -226,25 +226,26 @@ let result = str.replace(/(?<name>\w+) (?<surname>\w+)/, (...match) => {
 alert(result); // Smith, John
 ```
 
-Using a function gives us the ultimate replacement power, because it gets all the information about the match, has access to outer variables and can do everything.
+Usando una función nos da todo el poder del reemplazo, porque obtiene toda la información de la coincidencia, ya que tiene acceso a las variables externas y se puede hacer de todo.
 
 ## regexp.exec(str)
 
-The method `regexp.exec(str)` method returns a match for `regexp` in the string `str`.  Unlike previous methods, it's called on a regexp, not on a string.
+El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`regexp`) en la cadena (`str`). A diferencia de los metodos anteriores, se llama en una expresión regular en lugar de en una cadena.
 
-It behaves differently depending on whether the regexp has flag `pattern:g`.
 
-If there's no `pattern:g`, then `regexp.exec(str)` returns the first match exactly as  `str.match(regexp)`. This behavior doesn't bring anything new.
+Se comporta de manera diferente dependiendo de sí la expresión regular tiene la bandera `pattern:g` o no.
 
-But if there's flag `pattern:g`, then:
-- A call to `regexp.exec(str)` returns the first match and saves the position immediately after it in the property `regexp.lastIndex`.
-- The next such call starts the search from position `regexp.lastIndex`, returns the next match and saves the position after it in `regexp.lastIndex`.
-- ...And so on.
-- If there are no matches, `regexp.exec` returns `null` and resets `regexp.lastIndex` to `0`.
+Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
-So, repeated calls return all matches one after another, using property `regexp.lastIndex` to keep track of the current search position.
+Pero si hay la bandera `pattern:g`, entonces:
+- Una llamda a `regexp.exec(str)` retorna la primera coincidencia and y guarda la posición inmediatamante después en `regexp.lastIndex`.
+- La siguente llamada de la busqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
+- ...y así consecutivamente.
+- Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.
 
-In the past, before the method `str.matchAll` was added to JavaScript, calls of `regexp.exec` were used in the loop to get all matches with groups:
+Entonces, repetidas llamadas todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.
+
+En el pasado, antes el método `str.matchAll` fue agregado a JavaScript, llamadas de `regexp.exec` se utilizaron en el ciclo para obtener todas las coincidencias con sus grupos:
 
 ```js run
 let str = 'More about JavaScript at https://javascript.info';
@@ -254,56 +255,56 @@ let result;
 
 while (result = regexp.exec(str)) {
   alert( `Found ${result[0]} at position ${result.index}` );
-  // Found JavaScript at position 11, then
-  // Found javascript at position 33
+  // Se encontró JavaScript en la posición 11, luego
+  // Se encontró javascript en la posición 33
 }
 ```
 
-This works now as well, although for newer browsers `str.matchAll` is usually more convenient.
+Esto también, aunque para navegadores modernos `str.matchAll` es lo más conveniente.
 
-**We can use `regexp.exec` to search from a given position by manually setting `lastIndex`.**
+**Podemos usar `regexp.exec` para buscar desde una posición dada configurando manualmente el `lastIndex`.**
 
-For instance:
+Por ejemplo:
 
 ```js run
-let str = 'Hello, world!';
+let str = 'Hola, mundo!';
 
-let regexp = /\w+/g; // without flag "g", lastIndex property is ignored
-regexp.lastIndex = 5; // search from 5th position (from the comma)
+let regexp = /\w+/g; // sin la bandera "g", la propiedad `lastIndex` es ignorada
+regexp.lastIndex = 5; // buscar desde la 5ta posición (desde la coma)
 
-alert( regexp.exec(str) ); // world
+alert( regexp.exec(str) ); // mundo
 ```
 
-If the regexp has flag `pattern:y`, then the search will be performed exactly at the  position `regexp.lastIndex`, not any further.
+Si la expresión regular tiene la bandera `pattern:y`, entonces la busqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.
 
-Let's replace flag `pattern:g` with `pattern:y` in the example above. There will be no matches, as there's no word at position `5`:
+Vamos a reemplazar la bandera `pattern:g` con `pattern:y` en el ejemplo anterior. No habrá coincidencias, ya que no hay palabra en la posiicón `5`:
 
 ```js run
 let str = 'Hello, world!';
 
 let regexp = /\w+/y;
-regexp.lastIndex = 5; // search exactly at position 5
+regexp.lastIndex = 5; // buscar exactamente en la posición 5
 
 alert( regexp.exec(str) ); // null
 ```
 
-That's convenient for situations when we need to "read" something from the string by a regexp at the exact position, not somewhere further.
+Es conveniente para situaciones cuando necesitamos "leer" algo de la cadena por una expresión regular en una posición exacta. That's convenient for situations when we need to "read" something from the string by a regexp at the exact position, no en otro lugar.
 
 ## regexp.test(str)
 
-The method `regexp.test(str)` looks for a match and returns `true/false` whether it exists.
+El método `regexp.test(str)` busca por una coincidencia y retorna `true/false` si existe.
 
-For instance:
+Por ejemplo:
 
 ```js run
 let str = "I love JavaScript";
 
-// these two tests do the same
+// estas dos pruebas hacen lo mismo
 alert( *!*/love/i*/!*.test(str) ); // true
 alert( str.search(*!*/love/i*/!*) != -1 ); // true
 ```
 
-An example with the negative answer:
+Un ejemplo con respuesta negativa:
 
 ```js run
 let str = "Bla-bla-bla";
@@ -312,33 +313,33 @@ alert( *!*/love/i*/!*.test(str) ); // false
 alert( str.search(*!*/love/i*/!*) != -1 ); // false
 ```
 
-If the regexp has flag `pattern:g`, then `regexp.test` looks from `regexp.lastIndex` property and updates this property, just like `regexp.exec`.
+Si la expresión regular tiene la bandera `pattern:g`, el método `regexp.test` busca la propiedad `regexp.lastIndex` y la actualiza, igual que `regexp.exec`.
 
-So we can use it to search from a given position:
+Entonces podemos usarlo para buscar desde un posición dada:
 
 ```js run
 let regexp = /love/gi;
 
 let str = "I love JavaScript";
 
-// start the search from position 10:
+// comienza la busqueda desde la posición 10:
 regexp.lastIndex = 10;
-alert( regexp.test(str) ); // false (no match)
+alert( regexp.test(str) ); // false (sin coincidencia)
 ```
 
-````warn header="Same global regexp tested repeatedly on different sources may fail"
-If we apply the same global regexp to different inputs, it may lead to wrong result, because `regexp.test` call advances `regexp.lastIndex` property, so the search in another string may start from non-zero position.
+````warn header="La misma expresión regular probada (de manera global) repetidamente en diferentes lugares puede fallar"
+Si nosotros aplicamos la misma expresión regular (de manera global) a diferentes entradas, puede causar resultados incorrectos, porque `regexp.test` anticipa las llamadas usando la propiedad `regexp.lastIndex`, por lo que la busqueda en otra cadena puede comenzar desde una posición distinta a cero.
 
-For instance, here we call `regexp.test` twice on the same text, and the second time fails:
+Por ejemplo, podemos llamarlo aquí `regexp.test` dos veces en el mismo texto y en la segunda vez falla:
 
 ```js run
-let regexp = /javascript/g;  // (regexp just created: regexp.lastIndex=0)
+let regexp = /javascript/g;  // (expresión regular creada: regexp.lastIndex=0)
 
-alert( regexp.test("javascript") ); // true (regexp.lastIndex=10 now)
+alert( regexp.test("javascript") ); // true (regexp.lastIndex=10 ahora)
 alert( regexp.test("javascript") ); // false
 ```
 
-That's exactly because `regexp.lastIndex` is non-zero in the second test.
+Eso es exactamente porque `regexp.lastIndex` no es cero en la segunda prueba.
 
-To work around that, we can set `regexp.lastIndex = 0` before each search. Or instead of calling methods on regexp, use string methods `str.match/search/...`, they don't use `lastIndex`.
-````
+Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada busqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
+````
\ No newline at end of file

From 54be322c620a604df6be71c1c587f034bedc5805 Mon Sep 17 00:00:00 2001
From: danilobrinu <ddbn.c2@gmail.com>
Date: Thu, 8 Oct 2020 20:47:34 -0500
Subject: [PATCH 02/53] Minor changes

---
 9-regular-expressions/17-regexp-methods/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 920105723..7f3907e26 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -26,7 +26,7 @@ Tiene 3 modos:
 
 2. Si la expresión regular (`regexp`) tiene la bandera `pattern:g`, retorna una lista de todas las coincidencias como cadenas, sin capturar grupos y otros detalles.
     ```js run
-    let str = "Yo amo JavaScript";
+    let str = "I love JavaScript";
 
     let result = str.match(/Java(Script)/g);
 
@@ -39,7 +39,7 @@ Tiene 3 modos:
     Esto es algo mmuy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidandolo, ej.:
 
     ```js run
-    let str = "Yo amo JavaScript";
+    let str = "I love JavaScript";
 
     let result = str.match(/HTML/);
 

From 8ef9599a6315131544fc64a9a22b8e362dd2ef7e Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 00:40:55 -0500
Subject: [PATCH 03/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 7f3907e26..311f554c8 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -59,7 +59,7 @@ Tiene 3 modos:
 
 El método `str.matchAll(regexp)` es una variante ("nueva y mejorada") de `str.match`.
 
-Es usado principalmente para buscar por todas las coincidencias con todo todos los grupos.
+Es usado principalmente para buscar por todas las coincidencias con todos los grupos.
 
 Hay 3 diferencias con `match`:
 
@@ -342,4 +342,4 @@ alert( regexp.test("javascript") ); // false
 Eso es exactamente porque `regexp.lastIndex` no es cero en la segunda prueba.
 
 Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada busqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
-````
\ No newline at end of file
+````

From 4d415713a72949f442915956ba23ecc1ca22b37e Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 00:46:04 -0500
Subject: [PATCH 04/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 311f554c8..32e2045fa 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -125,7 +125,7 @@ Este es un método genérico para buscar y reemplazar, uno de los más útiles.
 Podemos usarlo sin expresiones regular, para buscar y reemplazar una sub-cadena:
 
 ```js run
-// reemplazar guión por dos puntos
+// reemplazar guion por dos puntos
 alert('12-34-56'.replace("-", ":")) // 12:34-56
 ```
 

From 7b2518f35cce99797c92fa264b25a08fb8c3c0f0 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 00:46:50 -0500
Subject: [PATCH 05/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 32e2045fa..a7cc2e210 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -335,7 +335,7 @@ Por ejemplo, podemos llamarlo aquí `regexp.test` dos veces en el mismo texto y
 ```js run
 let regexp = /javascript/g;  // (expresión regular creada: regexp.lastIndex=0)
 
-alert( regexp.test("javascript") ); // true (regexp.lastIndex=10 ahora)
+alert( regexp.test("javascript") ); // true (ahora es regexp.lastIndex=10 )
 alert( regexp.test("javascript") ); // false
 ```
 

From 7a161040f1242d383673434f8e12b98d153b8e7a Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 00:53:23 -0500
Subject: [PATCH 06/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index a7cc2e210..ee447077e 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -172,7 +172,7 @@ La función es llamada con los siguientes argumentos `func(match, p1, p2, ..., p
 2. `p1, p2, ..., pn` -- contenido de los grupos capturados (si hay alguno),
 3. `offset` -- posición de la coincidencia,
 4. `input` -- la cadena de entrada,
-5. `groups` -- un objecto con los grupos nombrados.
+5. `groups` -- un objeto con los grupos nombrados.
 
 Si hay paréntesis en la expresión regular, entonces solo son 3 argumentos: `func(str, offset, input)`.
 

From 1e5511aec75b4553ab6333310cb2dd2363f98230 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:36:47 -0500
Subject: [PATCH 07/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index ee447077e..809776c04 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -101,7 +101,7 @@ alert('12-34-56'.split('-')) // lista de [12, 34, 56]
 O también dividir una cadena usando una expresión regular de la misma forma:
 
 ```js run
-alert('12, 34, 56'.split(/,\s*/)) // lista de [12, 34, 56]
+alert('12, 34, 56'.split(/,\s*/)) // array de [12, 34, 56]
 ```
 
 ## str.search(regexp)

From 8751d21f5f069069f9854773b04cf1b1a4c4bb76 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:37:09 -0500
Subject: [PATCH 08/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 809776c04..4bba85158 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -288,7 +288,7 @@ regexp.lastIndex = 5; // buscar exactamente en la posición 5
 alert( regexp.exec(str) ); // null
 ```
 
-Es conveniente para situaciones cuando necesitamos "leer" algo de la cadena por una expresión regular en una posición exacta. That's convenient for situations when we need to "read" something from the string by a regexp at the exact position, no en otro lugar.
+Esto es conveniente cuando con una expresión regular necesitamos "leer" algo de la cadena en una posición exacta, no en otro lugar.
 
 ## regexp.test(str)
 

From 16d7b4087fe9c63853f6678732ce5f3dc0e5cc75 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:38:12 -0500
Subject: [PATCH 09/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 4bba85158..a1bd8ab9d 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -63,7 +63,7 @@ Es usado principalmente para buscar por todas las coincidencias con todos los gr
 
 Hay 3 diferencias con `match`:
 
-1. Retorna un objecto iterable con las coincidencias en lugar de una lista. Podemos convertirlo en una lista usando el método `Array.from`.
+1. Retorna un objeto iterable con las coincidencias en lugar de una lista. Podemos convertirlo en una lista usando el método `Array.from`.
 2. Cada coincidencia es retornada como una lista con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
 3. Si no hay resultados, no retorna `null`, pero si un objecto iterable vacío.
 

From d68d2e5bef582d2e7aca23d426ea2811c8d7d9f7 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:42:01 -0500
Subject: [PATCH 10/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index a1bd8ab9d..b917df347 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -47,7 +47,7 @@ Tiene 3 modos:
     alert(result.length); // Error: Cannot read property 'length' of null
     ```
 
-    Si queremos que el resultado sea una lista, podemos escribirlo así:
+    Si queremos que el resultado sea un array, podemos escribirlo así:
 
     ```js
     let result = str.match(regexp) || [];

From 926c7e8f5c5de535f0be501655b938b5dec69d38 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:42:12 -0500
Subject: [PATCH 11/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index b917df347..7be66ddba 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -63,7 +63,7 @@ Es usado principalmente para buscar por todas las coincidencias con todos los gr
 
 Hay 3 diferencias con `match`:
 
-1. Retorna un objeto iterable con las coincidencias en lugar de una lista. Podemos convertirlo en una lista usando el método `Array.from`.
+1. Retorna un objeto iterable con las coincidencias en lugar de un array. Podemos convertirlo en un array usando el método `Array.from`.
 2. Cada coincidencia es retornada como una lista con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
 3. Si no hay resultados, no retorna `null`, pero si un objecto iterable vacío.
 

From 67526f93c8246080596e72a3aae349f867b53571 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:51:47 -0500
Subject: [PATCH 12/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 7be66ddba..e8814be10 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -114,7 +114,7 @@ let str = "A drop of ink may make a million think";
 alert( str.search( /ink/i ) ); // 10 (posición de la primera coincidencia)
 ```
 
-**Limitación importante: solo `search` encuentra la primera coincidencia.**
+**Limitación importante: `search` solamente encuentra la primera coincidencia.**
 
 Si necesitamos las posiciones de las demás coincidencias, deberíamos usar otros medios, como encontrar todos con `str.matchAll(regexp)`.
 

From ca29636c53ca20031bac6891df207e9e0804b389 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:55:29 -0500
Subject: [PATCH 13/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index e8814be10..10a22cf6f 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -212,7 +212,7 @@ let result = str.replace(/(\w+) (\w+)/, (...match) => `${match[2]}, ${match[1]}`
 alert(result); // Smith, John
 ```
 
-O, si estamos usando grupos nombrados, entonces el objecto `groups` con ellos es siempre el último, por lo que podemos obtenerlos así:
+O, si estamos usando grupos nombrados, entonces el objeto `groups` con ellos es siempre el último, por lo que podemos obtenerlos así:
 
 ```js run
 let str = "John Smith";

From 3ba321c72fe656ef584a4bd7e4e7ba246fc0f8cc Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:58:36 -0500
Subject: [PATCH 14/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 10a22cf6f..b5e9d53dc 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -232,7 +232,6 @@ Usando una función nos da todo el poder del reemplazo, porque obtiene toda la i
 
 El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`regexp`) en la cadena (`str`). A diferencia de los metodos anteriores, se llama en una expresión regular en lugar de en una cadena.
 
-
 Se comporta de manera diferente dependiendo de sí la expresión regular tiene la bandera `pattern:g` o no.
 
 Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.

From 478c5c6325d8b2253cc2476f04d8ffb1139fecea Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:59:17 -0500
Subject: [PATCH 15/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index b5e9d53dc..bea1cfd38 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -232,7 +232,7 @@ Usando una función nos da todo el poder del reemplazo, porque obtiene toda la i
 
 El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`regexp`) en la cadena (`str`). A diferencia de los metodos anteriores, se llama en una expresión regular en lugar de en una cadena.
 
-Se comporta de manera diferente dependiendo de sí la expresión regular tiene la bandera `pattern:g` o no.
+Se comporta de manera diferente dependiendo de si la expresión regular tiene la bandera `pattern:g` o no.
 
 Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 

From 369b9c08001e756c86747ac5faef0f2fedea4c86 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 08:59:45 -0500
Subject: [PATCH 16/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index bea1cfd38..570415878 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -236,7 +236,7 @@ Se comporta de manera diferente dependiendo de si la expresión regular tiene la
 
 Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
-Pero si hay la bandera `pattern:g`, entonces:
+Pero si está la bandera `pattern:g`, entonces:
 - Una llamda a `regexp.exec(str)` retorna la primera coincidencia and y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - La siguente llamada de la busqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - ...y así consecutivamente.

From 3ecea792550678de6f4c8d2ba58b591845015c3c Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:00:14 -0500
Subject: [PATCH 17/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 570415878..def16e912 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -237,7 +237,7 @@ Se comporta de manera diferente dependiendo de si la expresión regular tiene la
 Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
 Pero si está la bandera `pattern:g`, entonces:
-- Una llamda a `regexp.exec(str)` retorna la primera coincidencia and y guarda la posición inmediatamante después en `regexp.lastIndex`.
+- Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - La siguente llamada de la busqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - ...y así consecutivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.

From 8096bbbb827ac8968612bd5d9a7d7db2547f5a5a Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:00:37 -0500
Subject: [PATCH 18/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index def16e912..f547d9ca2 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -238,7 +238,7 @@ Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera
 
 Pero si está la bandera `pattern:g`, entonces:
 - Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
-- La siguente llamada de la busqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
+- La siguente llamada de la búsqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - ...y así consecutivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.
 

From f24cab8042a012e955362e550de94de36467760b Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:03:17 -0500
Subject: [PATCH 19/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index f547d9ca2..db6b92360 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -239,7 +239,7 @@ Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera
 Pero si está la bandera `pattern:g`, entonces:
 - Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - La siguente llamada de la búsqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
-- ...y así consecutivamente.
+- ...y así sucesivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.
 
 Entonces, repetidas llamadas todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.

From 0c276b1e94411f2d2630339b7054115c0959ec9b Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:03:31 -0500
Subject: [PATCH 20/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index db6b92360..eee2d7e53 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -276,7 +276,7 @@ alert( regexp.exec(str) ); // mundo
 
 Si la expresión regular tiene la bandera `pattern:y`, entonces la busqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.
 
-Vamos a reemplazar la bandera `pattern:g` con `pattern:y` en el ejemplo anterior. No habrá coincidencias, ya que no hay palabra en la posiicón `5`:
+Vamos a reemplazar la bandera `pattern:g` con `pattern:y` en el ejemplo anterior. No habrá coincidencias, ya que no hay palabra en la posición `5`:
 
 ```js run
 let str = 'Hello, world!';

From 3c5ed4a80c89b60621eb9e8ee9d47237a9674acf Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:03:51 -0500
Subject: [PATCH 21/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index eee2d7e53..9a5042b5e 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -242,7 +242,7 @@ Pero si está la bandera `pattern:g`, entonces:
 - ...y así sucesivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.
 
-Entonces, repetidas llamadas todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.
+Entonces, repetidas llamadas retornan todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.
 
 En el pasado, antes el método `str.matchAll` fue agregado a JavaScript, llamadas de `regexp.exec` se utilizaron en el ciclo para obtener todas las coincidencias con sus grupos:
 

From 6ea33d01a9365d1f0eb45a82c04c4aa0b4c90eba Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:05:12 -0500
Subject: [PATCH 22/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 9a5042b5e..266f1a8ed 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -274,7 +274,7 @@ regexp.lastIndex = 5; // buscar desde la 5ta posición (desde la coma)
 alert( regexp.exec(str) ); // mundo
 ```
 
-Si la expresión regular tiene la bandera `pattern:y`, entonces la busqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.
+Si la expresión regular tiene la bandera `pattern:y`, entonces la búsqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.
 
 Vamos a reemplazar la bandera `pattern:g` con `pattern:y` en el ejemplo anterior. No habrá coincidencias, ya que no hay palabra en la posición `5`:
 

From 8ebc9f2bc5dc2f5549b880bd3db7c88a94be96d9 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:05:56 -0500
Subject: [PATCH 23/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 266f1a8ed..81593e352 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -244,7 +244,7 @@ Pero si está la bandera `pattern:g`, entonces:
 
 Entonces, repetidas llamadas retornan todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.
 
-En el pasado, antes el método `str.matchAll` fue agregado a JavaScript, llamadas de `regexp.exec` se utilizaron en el ciclo para obtener todas las coincidencias con sus grupos:
+En el pasado, antes de que el método `str.matchAll` fuera agregado a JavaScript, se utilizaban llamadas de `regexp.exec` en el ciclo para obtener todas las coincidencias con sus grupos:
 
 ```js run
 let str = 'More about JavaScript at https://javascript.info';

From 1099fca02ea8aa4f38155ee0b184bec4be9b77df Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:07:07 -0500
Subject: [PATCH 24/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 81593e352..2889c1502 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -253,7 +253,7 @@ let regexp = /javascript/ig;
 let result;
 
 while (result = regexp.exec(str)) {
-  alert( `Found ${result[0]} at position ${result.index}` );
+  alert( `Se encontró ${result[0]} en la posición ${result.index}` );
   // Se encontró JavaScript en la posición 11, luego
   // Se encontró javascript en la posición 33
 }

From 6dab29bb93492abdeec656178739710247ba523f Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:08:10 -0500
Subject: [PATCH 25/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 2889c1502..4c34a0775 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -234,7 +234,7 @@ El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`
 
 Se comporta de manera diferente dependiendo de si la expresión regular tiene la bandera `pattern:g` o no.
 
-Si no hay la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coindicencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
+Si no está bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coincidencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
 Pero si está la bandera `pattern:g`, entonces:
 - Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.

From abb948bade9c8b40f74e366205f4febd0b9115b8 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:37:01 -0500
Subject: [PATCH 26/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 4c34a0775..5a6d4944f 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -24,7 +24,7 @@ Tiene 3 modos:
     alert( result.input );  // I love JavaScript (cadena de entrada)
     ```
 
-2. Si la expresión regular (`regexp`) tiene la bandera `pattern:g`, retorna una lista de todas las coincidencias como cadenas, sin capturar grupos y otros detalles.
+2. Si la expresión regular (`regexp`) tiene la bandera `pattern:g`, retorna un array de todas las coincidencias como cadenas, sin capturar grupos y otros detalles.
     ```js run
     let str = "I love JavaScript";
 

From 38c0dc30170d04cec5cc4b80dc9a1558715029d4 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:37:10 -0500
Subject: [PATCH 27/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 5a6d4944f..99d849eea 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -95,7 +95,7 @@ Divide la cadena usando la expresión regular (o una sub-cadena) como delimitado
 Podemos usar `split` con cadenas, así:
 
 ```js run
-alert('12-34-56'.split('-')) // lista de [12, 34, 56]
+alert('12-34-56'.split('-')) // array de [12, 34, 56]
 ```
 
 O también dividir una cadena usando una expresión regular de la misma forma:

From 7230edf48ea879e803293cf75bf0a914180cd32c Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:37:21 -0500
Subject: [PATCH 28/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 99d849eea..3df0a6de6 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -8,7 +8,7 @@ El método `str.match(regexp)` encuentra coincidencias para las expresiones regu
 
 Tiene 3 modos:
 
-1. Si la expresión regular (`regexp`) no tiene la bandera `pattern:g`, retorna una lista con los grupos capturados y las propiedades `index` (posición de la coincidencia), `input` (cadena de entrada, igual a `str`):
+1. Si la expresión regular (`regexp`) no tiene la bandera `pattern:g`, retorna un array con los grupos capturados y las propiedades `index` (posición de la coincidencia), `input` (cadena de entrada, igual a `str`):
 
     ```js run
     let str = "I love JavaScript";

From 4dc4d5cc4365d466424c5f66e32722edd4fae02e Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:37:32 -0500
Subject: [PATCH 29/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 3df0a6de6..22d7167c4 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -77,7 +77,7 @@ let matchAll = str.matchAll(regexp);
 
 alert(matchAll); // [object RegExp String Iterator], no es una lista, pero si un objeto iterable
 
-matchAll = Array.from(matchAll); // ahora es una lista
+matchAll = Array.from(matchAll); // ahora es un array
 
 let firstMatch = matchAll[0];
 alert( firstMatch[0] );  // <h1>

From d89d22e073a5e380af42bfebdc8447ad7e63a2ca Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:47:44 -0500
Subject: [PATCH 30/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 22d7167c4..04a47cfd1 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -75,7 +75,7 @@ let regexp = /<(.*?)>/g;
 
 let matchAll = str.matchAll(regexp);
 
-alert(matchAll); // [object RegExp String Iterator], no es una lista, pero si un objeto iterable
+alert(matchAll); // [object RegExp String Iterator], no es un array, pero si un objeto iterable
 
 matchAll = Array.from(matchAll); // ahora es un array
 

From a48a24c02c48dab21f4722a6a637afb33821b7d6 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:47:55 -0500
Subject: [PATCH 31/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 04a47cfd1..1020fa087 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -64,7 +64,7 @@ Es usado principalmente para buscar por todas las coincidencias con todos los gr
 Hay 3 diferencias con `match`:
 
 1. Retorna un objeto iterable con las coincidencias en lugar de un array. Podemos convertirlo en un array usando el método `Array.from`.
-2. Cada coincidencia es retornada como una lista con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
+2. Cada coincidencia es retornada como un array con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
 3. Si no hay resultados, no retorna `null`, pero si un objecto iterable vacío.
 
 Ejemplo de uso:

From 09f1a58f026d104a602f65ee24e410d36256201c Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 09:49:29 -0500
Subject: [PATCH 32/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 1020fa087..129f11c26 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -334,7 +334,7 @@ Por ejemplo, podemos llamarlo aquí `regexp.test` dos veces en el mismo texto y
 ```js run
 let regexp = /javascript/g;  // (expresión regular creada: regexp.lastIndex=0)
 
-alert( regexp.test("javascript") ); // true (ahora es regexp.lastIndex=10 )
+alert( regexp.test("javascript") ); // true (ahora regexp.lastIndex es 10)
 alert( regexp.test("javascript") ); // false
 ```
 

From a2b592684778e5431c4c3db36c8a0bca6582a989 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:53:44 -0500
Subject: [PATCH 33/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 129f11c26..5aa58f24c 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -75,7 +75,7 @@ let regexp = /<(.*?)>/g;
 
 let matchAll = str.matchAll(regexp);
 
-alert(matchAll); // [object RegExp String Iterator], no es un array, pero si un objeto iterable
+alert(matchAll); // [object RegExp String Iterator], no es un array, pero sí un objeto iterable
 
 matchAll = Array.from(matchAll); // ahora es un array
 

From 87a8ca35d4ed843bcb48e11d84168d9556284c4a Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:09 -0500
Subject: [PATCH 34/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 5aa58f24c..725ede30c 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -34,7 +34,7 @@ Tiene 3 modos:
     alert( result.length ); // 1
     ```
 
-3. Si no hay coincidencias, no importa si tiene la bandera `pattern:g` o no, `null` es retornado.
+3. Si no hay coincidencias, no importa si tiene la bandera `pattern:g` o no,  retorna `null` .
 
     Esto es algo mmuy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidandolo, ej.:
 

From 817bd2ebea0aa5c05bdb7d763c139d48448b638e Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:18 -0500
Subject: [PATCH 35/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 725ede30c..22cc6c526 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -122,7 +122,7 @@ Si necesitamos las posiciones de las demás coincidencias, deberíamos usar otro
 
 Este es un método genérico para buscar y reemplazar, uno de los más útiles. La navaja suiza para buscar y reemplazar.  
 
-Podemos usarlo sin expresiones regular, para buscar y reemplazar una sub-cadena:
+Podemos usarlo sin expresiones regulares, para buscar y reemplazar una sub-cadena:
 
 ```js run
 // reemplazar guion por dos puntos

From d58b0de1bf57ab8c5e5433d3a0068492a09871ce Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:27 -0500
Subject: [PATCH 36/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 22cc6c526..669e1eaee 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -321,7 +321,7 @@ let regexp = /love/gi;
 
 let str = "I love JavaScript";
 
-// comienza la busqueda desde la posición 10:
+// comienza la búsqueda desde la posición 10:
 regexp.lastIndex = 10;
 alert( regexp.test(str) ); // false (sin coincidencia)
 ```

From 598013b845bacf75f5c8a53aa0d322191484a248 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:37 -0500
Subject: [PATCH 37/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 669e1eaee..3f54bd3a5 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -242,7 +242,7 @@ Pero si está la bandera `pattern:g`, entonces:
 - ...y así sucesivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.
 
-Entonces, repetidas llamadas retornan todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la busqueda.
+Entonces, repetidas llamadas retornan todas las coincidencias una tras otra, usando la propiedad `regexp.lastIndex` para realizar el rastreo de la posición actual de la búsqueda.
 
 En el pasado, antes de que el método `str.matchAll` fuera agregado a JavaScript, se utilizaban llamadas de `regexp.exec` en el ciclo para obtener todas las coincidencias con sus grupos:
 

From aa873bd29d3b67867d320121ad3fbf1276c4bcb5 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:46 -0500
Subject: [PATCH 38/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 3f54bd3a5..564b28c9b 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -340,5 +340,5 @@ alert( regexp.test("javascript") ); // false
 
 Eso es exactamente porque `regexp.lastIndex` no es cero en la segunda prueba.
 
-Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada busqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
+Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada búsqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
 ````

From 14219dcde23d5d15ea5bc9251898380a23ed68aa Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:54:54 -0500
Subject: [PATCH 39/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 564b28c9b..a3df08e51 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -327,7 +327,7 @@ alert( regexp.test(str) ); // false (sin coincidencia)
 ```
 
 ````warn header="La misma expresión regular probada (de manera global) repetidamente en diferentes lugares puede fallar"
-Si nosotros aplicamos la misma expresión regular (de manera global) a diferentes entradas, puede causar resultados incorrectos, porque `regexp.test` anticipa las llamadas usando la propiedad `regexp.lastIndex`, por lo que la busqueda en otra cadena puede comenzar desde una posición distinta a cero.
+Si nosotros aplicamos la misma expresión regular (de manera global) a diferentes entradas, puede causar resultados incorrectos, porque `regexp.test` anticipa las llamadas usando la propiedad `regexp.lastIndex`, por lo que la búsqueda en otra cadena puede comenzar desde una posición distinta a cero.
 
 Por ejemplo, podemos llamarlo aquí `regexp.test` dos veces en el mismo texto y en la segunda vez falla:
 

From b8c8fa6b593758c9a8fc55cf4cdf13382ba12072 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:55:01 -0500
Subject: [PATCH 40/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index a3df08e51..bd2c6c9f3 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -234,7 +234,7 @@ El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`
 
 Se comporta de manera diferente dependiendo de si la expresión regular tiene la bandera `pattern:g` o no.
 
-Si no está bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coincidencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
+Si no está la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coincidencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
 Pero si está la bandera `pattern:g`, entonces:
 - Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.

From 36f4b5c1a87cd7ebf011fa063681b67944ba8f55 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:55:08 -0500
Subject: [PATCH 41/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index bd2c6c9f3..fe1414925 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -65,7 +65,7 @@ Hay 3 diferencias con `match`:
 
 1. Retorna un objeto iterable con las coincidencias en lugar de un array. Podemos convertirlo en un array usando el método `Array.from`.
 2. Cada coincidencia es retornada como un array con los grupos capturados (el mismo formato de `str.match` sin la bandera `pattern:g`).
-3. Si no hay resultados, no retorna `null`, pero si un objecto iterable vacío.
+3. Si no hay resultados, no retorna `null`, pero sí un objeto iterable vacío.
 
 Ejemplo de uso:
 

From 7fbbefdb58ed512f28f5b595b6bdbf1b31611d8a Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:55:16 -0500
Subject: [PATCH 42/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index fe1414925..53e542991 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -36,7 +36,7 @@ Tiene 3 modos:
 
 3. Si no hay coincidencias, no importa si tiene la bandera `pattern:g` o no,  retorna `null` .
 
-    Esto es algo mmuy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidandolo, ej.:
+    Esto es algo muy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidándolo, ej.:
 
     ```js run
     let str = "I love JavaScript";

From e677a048da62f73b290ab840c665e5d67f949e5f Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 11:57:32 -0500
Subject: [PATCH 43/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 53e542991..2485537bb 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -149,7 +149,7 @@ El segundo argumento es la cadena de reemplazo. Podemos usar caracteres especial
 |`$&`|inserta toda la coincidencia|
 |<code>$&#096;</code>|inserta una parte de la cadena antes de la coincidencia|
 |`$'`|inserta una parte de la cadena después de la coincidencia|
-|`$n`|si `n` es un 1-2 dígito númerico, inserta el contenido del enésimo grupo capturado, para más detalles ver [](info:regexp-groups)|
+|`$n`|si `n` es un número, inserta el contenido del enésimo grupo capturado, para más detalles ver [](info:regexp-groups)|
 |`$<nombre>`|inserta el contenido de los paréntesis con el `nombre` dado, para más detalles ver [](info:regexp-groups)|
 |`$$`|inserta el carácter `$` |
 

From 9acec7262c714e6dc1ed5871f00ccadc8e34b2e3 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:54:02 -0500
Subject: [PATCH 44/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 2485537bb..14fb38761 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -36,7 +36,7 @@ Tiene 3 modos:
 
 3. Si no hay coincidencias, no importa si tiene la bandera `pattern:g` o no,  retorna `null` .
 
-    Esto es algo muy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero si un `null`. Es fácil cometer un error olvidándolo, ej.:
+    Esto es algo muy importante. Si no hay coincidencias, no vamos a obtener un array vacío, pero sí un `null`. Es fácil cometer un error olvidándolo, ej.:
 
     ```js run
     let str = "I love JavaScript";

From 72cf0c64ecd622146840c73a588fb4d588456338 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:54:16 -0500
Subject: [PATCH 45/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 14fb38761..e1048bd87 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -338,7 +338,7 @@ alert( regexp.test("javascript") ); // true (ahora regexp.lastIndex es 10)
 alert( regexp.test("javascript") ); // false
 ```
 
-Eso es exactamente porque `regexp.lastIndex` no es cero en la segunda prueba.
+Eso es porque `regexp.lastIndex` no es cero en la segunda prueba.
 
 Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada búsqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
 ````

From 9e5ef9a10965f476f32043206a295a6755492723 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:54:39 -0500
Subject: [PATCH 46/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index e1048bd87..3cee9eef1 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -230,7 +230,7 @@ Usando una función nos da todo el poder del reemplazo, porque obtiene toda la i
 
 ## regexp.exec(str)
 
-El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`regexp`) en la cadena (`str`). A diferencia de los metodos anteriores, se llama en una expresión regular en lugar de en una cadena.
+El método `regexp.exec(str)` retorna una coincidencia por expresión regular (`regexp`) en la cadena (`str`). A diferencia de los métodos anteriores, se llama en una expresión regular en lugar de en una cadena.
 
 Se comporta de manera diferente dependiendo de si la expresión regular tiene la bandera `pattern:g` o no.
 

From a2e4467b7970b8533c35c0c229b26941ceb84106 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:54:51 -0500
Subject: [PATCH 47/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 3cee9eef1..525e22bec 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -340,5 +340,5 @@ alert( regexp.test("javascript") ); // false
 
 Eso es porque `regexp.lastIndex` no es cero en la segunda prueba.
 
-Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada búsqueda. O en lugar de llamar a los metodos en la expresión regular usar los metodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
+Para solucionarlo, podemos establecer `regexp.lastIndex = 0` antes de cada búsqueda. O en lugar de llamar a los métodos en la expresión regular usar los métodos de cadena `str.match/search/...`, ellos no usan el `lastIndex`.
 ````

From e9c5ba7a5fcbc0d1cd1c77f1a476c25c9fa3b6c3 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:55:14 -0500
Subject: [PATCH 48/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 525e22bec..e87288a73 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -329,7 +329,7 @@ alert( regexp.test(str) ); // false (sin coincidencia)
 ````warn header="La misma expresión regular probada (de manera global) repetidamente en diferentes lugares puede fallar"
 Si nosotros aplicamos la misma expresión regular (de manera global) a diferentes entradas, puede causar resultados incorrectos, porque `regexp.test` anticipa las llamadas usando la propiedad `regexp.lastIndex`, por lo que la búsqueda en otra cadena puede comenzar desde una posición distinta a cero.
 
-Por ejemplo, podemos llamarlo aquí `regexp.test` dos veces en el mismo texto y en la segunda vez falla:
+Por ejemplo, aquí llamamos `regexp.test` dos veces en el mismo texto y en la segunda vez falla:
 
 ```js run
 let regexp = /javascript/g;  // (expresión regular creada: regexp.lastIndex=0)

From f55acf7be89908e4872f025bcb827db585f870c4 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:56:06 -0500
Subject: [PATCH 49/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index e87288a73..c24881aac 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -266,7 +266,7 @@ Esto también, aunque para navegadores modernos `str.matchAll` es lo más conven
 Por ejemplo:
 
 ```js run
-let str = 'Hola, mundo!';
+let str = 'Hello, world!';
 
 let regexp = /\w+/g; // sin la bandera "g", la propiedad `lastIndex` es ignorada
 regexp.lastIndex = 5; // buscar desde la 5ta posición (desde la coma)

From bd7e4560986f7ecad8104b60d72bc412f9cf9cbd Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:56:53 -0500
Subject: [PATCH 50/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index c24881aac..fa9a49edb 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -259,7 +259,7 @@ while (result = regexp.exec(str)) {
 }
 ```
 
-Esto también, aunque para navegadores modernos `str.matchAll` es lo más conveniente.
+Esto también funciona, aunque para navegadores modernos `str.matchAll` usualmente es lo más conveniente.
 
 **Podemos usar `regexp.exec` para buscar desde una posición dada configurando manualmente el `lastIndex`.**
 

From 89d3487519201f044405fc86aa5142e719539398 Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 13:57:37 -0500
Subject: [PATCH 51/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index fa9a49edb..da0db440f 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -237,7 +237,7 @@ Se comporta de manera diferente dependiendo de si la expresión regular tiene la
 Si no está la bandera `pattern:g`, entonces `regexp.exec(str)` retorna la primera coincidencia igual que `str.match(regexp)`. Este comportamiento no trae nada nuevo.
 
 Pero si está la bandera `pattern:g`, entonces:
-- Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
+- Una llamda a `regexp.exec(str)` retorna la primera coincidencia y guarda la posición inmediatamente después en `regexp.lastIndex`.
 - La siguente llamada de la búsqueda comienza desde la posición de `regexp.lastIndex`, retorna la siguiente coincidencia y guarda la posición inmediatamante después en `regexp.lastIndex`.
 - ...y así sucesivamente.
 - Si no hay coincidencias, `regexp.exec` retorna `null` y resetea `regexp.lastIndex` a `0`.

From bb0743e0d526e201409104c558d1af1f8e4ccfbc Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 14:18:28 -0500
Subject: [PATCH 52/53] Update
 9-regular-expressions/17-regexp-methods/article.md

---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index da0db440f..45c34c6e0 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -271,7 +271,7 @@ let str = 'Hello, world!';
 let regexp = /\w+/g; // sin la bandera "g", la propiedad `lastIndex` es ignorada
 regexp.lastIndex = 5; // buscar desde la 5ta posición (desde la coma)
 
-alert( regexp.exec(str) ); // mundo
+alert( regexp.exec(str) ); // world!
 ```
 
 Si la expresión regular tiene la bandera `pattern:y`, entonces la búsqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.

From cd3db66fac3750bc328005d1e3bbda6accb2253a Mon Sep 17 00:00:00 2001
From: Danilo Britto <ddbn.c2@gmail.com>
Date: Fri, 9 Oct 2020 15:30:18 -0500
Subject: [PATCH 53/53] Update
 9-regular-expressions/17-regexp-methods/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 9-regular-expressions/17-regexp-methods/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/17-regexp-methods/article.md b/9-regular-expressions/17-regexp-methods/article.md
index 45c34c6e0..00d50c7a5 100644
--- a/9-regular-expressions/17-regexp-methods/article.md
+++ b/9-regular-expressions/17-regexp-methods/article.md
@@ -271,7 +271,7 @@ let str = 'Hello, world!';
 let regexp = /\w+/g; // sin la bandera "g", la propiedad `lastIndex` es ignorada
 regexp.lastIndex = 5; // buscar desde la 5ta posición (desde la coma)
 
-alert( regexp.exec(str) ); // world!
+alert( regexp.exec(str) ); // world
 ```
 
 Si la expresión regular tiene la bandera `pattern:y`, entonces la búsqueda se realizará exactamente en la posición del `regexp.lastIndex`, no más adelante.