From 99a9d12dd7aaac66b4dce51afced072ce3863d76 Mon Sep 17 00:00:00 2001
From: Jesus Ferney Salazar <68440053+MrC0D@users.noreply.github.com>
Date: Mon, 21 Sep 2020 17:08:35 -0500
Subject: [PATCH 01/11] Update article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Traducción casi finalizada, faltan pulir detalles en lo referente al uso de términos y la gramática, estoy atento a consejos.
---
 .../14-regexp-lookahead-lookbehind/article.md | 140 ++++++++----------
 1 file changed, 61 insertions(+), 79 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 48c82da14..41aac98c9 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,130 +1,112 @@
-# Lookahead and lookbehind
+# mirar adelante y mirar atras
 
-Sometimes we need to find only those matches for a pattern that are followed or preceeded by another pattern.
+A veces necesitamos buscar solo aquella coincidencia en un patron que es precedida o antecedida por otro patron.
 
-There's a special syntax for that, called "lookahead" and "lookbehind", together referred to as "lookaround".
-
-For the start, let's find the price from the string like `subject:1 turkey costs 30€`. That is: a number, followed by `subject:€` sign.
-
-## Lookahead
-
-The syntax is: `pattern:X(?=Y)`, it means "look for `pattern:X`, but match only if followed by `pattern:Y`". There may be any pattern instead of `pattern:X` and `pattern:Y`.
-
-For an integer number followed by `subject:€`, the regexp will be `pattern:\d+(?=€)`:
+Existe una sintaxis especial para eso, llamada "mirar adelante" y "mirar atras" (del ingles: _"lookahead" and "lookbehind"_ ) ,juntas conocidas como "mirar alrededor"
+para empezar, busquemos el precio de la cadena siguente `subject:1 pavo cuesta 30€`. eso es: un numero, seguido de `subject:€` signo  
+## mirar adelante
 
+La sintaxis es: `pattern:X(?=Y)`. esto significa "mirar por `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Deben haber algun patron en lugar de `pattern:X` and `pattern:Y`.  
+Para un numero entero seguido de `subject:€`, la expresion regular sera `pattern:\d+(?=€)`:
 ```js run
-let str = "1 turkey costs 30€";
+let str = "1 pavo cuesta 30€";
 
-alert( str.match(/\d+(?=€)/) ); // 30, the number 1 is ignored, as it's not followed by €
+alert( str.match(/\d+(?=€)/) ); // 30, el numero 1 es ignorad0, por que no tiene al lado a €
 ```
 
-Please note: the lookahead is merely a test, the contents of the parentheses `pattern:(?=...)` is not included in the result `match:30`.
-
-When we look for `pattern:X(?=Y)`, the regular expression engine finds `pattern:X` and then checks if there's `pattern:Y` immediately after it. If it's not so, then the potential match is skipped, and the search continues.
+por favor nota: el mirar adelante es solamente una prueba,lo contenido en los parentesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
+Cuando buscamos por `pattern:X(?=Y)`, el  buscador de expresion regular encuentra `pattern:X` y luego verifica si existe algun `pattern:Y` inmediatamente despues de el.Si no se cumple, entonces la posible coincidencia es omitida, y la busqueda continua.    
 
 More complex tests are possible, e.g. `pattern:X(?=Y)(?=Z)` means:
-
-1. Find `pattern:X`.
-2. Check if `pattern:Y` is immediately after `pattern:X` (skip if isn't).
-3. Check if `pattern:Z` is also immediately after `pattern:X` (skip if isn't).
-4. If both tests passed, then the `pattern:X` is a match, otherwise continue searching.
-
-In other words, such pattern means that we're looking for `pattern:X` followed by `pattern:Y` and `pattern:Z` at the same time.
-
-That's only possible if patterns `pattern:Y` and `pattern:Z` aren't mutually exclusive.
-
-For example, `pattern:\d+(?=\s)(?=.*30)` looks for `pattern:\d+` only if it's followed by a space, and there's `30` somewhere after it:
-
+Pruebas mas complejas son posibles, ejemplo.`pattern:X(?=Y)(?=Z)` significa:
+1. encuentra `pattern:X`.
+2. Verifica si `pattern:Y` es inmediatamente despues de `pattern:X` (omitir si no es).
+3. Verifica si `pattern:Z` es también inmediatamente después de `pattern:X` (omitir si no es).
+4. Si ambos casos se cumplen, entonces el `pattern:X` es una coincidencia, de lo contrario, continúe buscando.
+
+En otras palabras, dicho patron significa que estamos buscando por `pattern:X` seguido de `pattern:Y` y `pattern:Z` al mismo tiempo. 
+Eso solo es posible si los patrones `pattern:Y` y `pattern:Z` no son mutuamente exclusivos. 
+Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca por `pattern:\d+` solo si es seguido por un espacio, y si hay `30` en algun lugar despues de eso:
 ```js run
-let str = "1 turkey costs 30€";
+let str = "1 pavo cuesta 30€";
 
 alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 ```
 
-In our string that exactly matches the number `1`.
-
-## Negative lookahead
+En nuestra cadena eso coincide exactamente con el numero `1`. 
+## Mirada hacia delante negativa
 
-Let's say that we want a quantity instead, not a price from the same string. That's a number `pattern:\d+`, NOT followed by `subject:€`.
-
-For that, a negative lookahead can be applied.
-
-The syntax is: `pattern:X(?!Y)`, it means "search `pattern:X`, but only if not followed by `pattern:Y`".
+Digamos que queremos una cantidad, no un precio de la misma cadena.Eso es el numero `pattern:\d+`, NO seguido por `subject:€`.  
+Por eso, una mirada hacia delante negativa puede ser aplicada.
+La sintaxis es: `pattern:X(?!Y)`, la cual significa "busca `pattern:X`, pero solo si es seguido por `pattern:Y`".
 
 ```js run
-let str = "2 turkeys cost 60€";
+let str = "2 pavos cuestan 60€";
 
-alert( str.match(/\d+(?!€)/) ); // 2 (the price is skipped)
+alert( str.match(/\d+(?!€)/) ); // 2 (el precio es omitido)
 ```
 
-## Lookbehind
-
-Lookahead allows to add a condition for "what follows".
+## Mirar atras
 
-Lookbehind is similar, but it looks behind. That is, it allows to match a pattern only if there's something before it.
-
-The syntax is:
-- Positive lookbehind: `pattern:(?<=Y)X`, matches `pattern:X`, but only if there's  `pattern:Y` before it.
-- Negative lookbehind: `pattern:(?<!Y)X`, matches `pattern:X`, but only if there's no `pattern:Y` before it.
-
-For example, let's change the price to US dollars. The dollar sign is usually before the number, so to look for `$30` we'll use `pattern:(?<=\$)\d+` -- an amount preceded by `subject:$`:
+Mirar adelante permite agregar a una condicion para "que sigue".
+Mirar atras es similar, pero mira detras. Eso es, permite coincidir un patron solo si hay algo antes de el.
+La sintaxis es:
+- Mirar atras positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de el.
+- Mirar atras negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de el.
 
+Por ejemplo,cambiemos el precio a dolares estadounidenses. El signo de dollar usualmente va antes del numero, entonces miramos por `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
 ```js run
-let str = "1 turkey costs $30";
+let str = "1 pavo cuesta $30";
 
-// the dollar sign is escaped \$
-alert( str.match(/(?<=\$)\d+/) ); // 30 (skipped the sole number)
+// el signo de dolar es escapado \$
+alert( str.match(/(?<=\$)\d+/) ); // 30 (omitido el numero)
 ```
 
 And, if we need the quantity -- a number, not preceded by `subject:$`, then we can use a negative lookbehind `pattern:(?<!\$)\d+`:
-
+Y, si necesitamos la cantidad -- un numero, no precedida por  `subject:$`,entonces podemos usar un mirar atras negativo `pattern:(?<!\$)\d+`: 
 ```js run
-let str = "2 turkeys cost $60";
+let str = "2 pavos cuestan $60";
 
-alert( str.match(/(?<!\$)\d+/) ); // 2 (skipped the price)
+alert( str.match(/(?<!\$)\d+/) ); // 2 (precio omitido)
 ```
 
-## Capturing groups
+## Atrapando grupos
 
-Generally, the contents inside lookaround parentheses does not become a part of the result.
-
-E.g. in the pattern `pattern:\d+(?=€)`, the `pattern:€` sign doesn't get captured as a part of the match. That's natural: we look for a number `pattern:\d+`, while `pattern:(?=€)` is just a test that it should be followed by `subject:€`.
-
-But in some situations we might want to capture the lookaround expression as well, or a part of it. That's possible. Just wrap that part into additional parentheses.
-
-In the example below the currency sign `pattern:(€|kr)` is captured, along with the amount:
+Generalmente, los contenidos dentro de los parentesis de mirar alrededor no se convierten en parte del resultado.
+Ejemplo en el patron `pattern:\d+(?=€)`, el `pattern:€` signo no es capturado como parte de la coincidencia. Eso es esperado: buscamos un numero `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que deberia ser seguida por `subject:€`.
 
+Pero en algunas situaciones nosotros podriamos querer el capturar la expresion mirar alrededor, o parte de ella. Eso es posible. solo hay que rodear esa parte por parentesis adicionales
+En los ejemplos de abajo el signo de divisa  `pattern:(€|kr)` es capturado, junto con la cantidad:  
 ```js run
-let str = "1 turkey costs 30€";
-let regexp = /\d+(?=(€|kr))/; // extra parentheses around €|kr
+let str = "1 pavo cuesta 30€";
+let regexp = /\d+(?=(€|kr))/; // parentesis extra alrededor de €|kr
 
 alert( str.match(regexp) ); // 30, €
 ```
 
-And here's the same for lookbehind:
+Y esto es lo mismo para mirar atrás:
 
 ```js run
-let str = "1 turkey costs $30";
+let str = "1 pavo cuesta $30";
 let regexp = /(?<=(\$|£))\d+/;
 
 alert( str.match(regexp) ); // 30, $
 ```
 
-## Summary
+## Resumen
 
-Lookahead and lookbehind (commonly referred to as "lookaround") are useful when we'd like to match something depending on the context before/after it.
-
-For simple regexps we can do the similar thing manually. That is: match everything, in any context, and then filter by context in the loop.
+Mirar adelante y mirar atras (comúnmente conocido como "mirar alrededor") son útiles cuando nos gustaría hacer coincidir algo dependiendo del contexto antes / después.
 
+Para simples expresiones regulares podemos hacer lo mismo maualmente. Esto es:coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
 Remember, `str.match` (without flag `pattern:g`) and `str.matchAll` (always) return matches as arrays with `index` property, so we know where exactly in the text it is, and can check the context.
+Recuerda,`str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) retorna coincidencias como un arreglo con la propiedad `index`, ´pr ñp cual sabemos donde exactamente esta en el texto, y podemos verificar el contexto.
 
-But generally lookaround is more convenient.
-
-Lookaround types:
+Pero generalmente mirar alrededor es mas conveniente.
+tipos de mirar alrededor:
 
-| Pattern            | type             | matches |
+| Patron             | tipo             | coincidencias |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Positive lookahead | `pattern:X` if followed by `pattern:Y` |
-| `X(?!Y)`   | Negative lookahead | `pattern:X` if not followed by `pattern:Y` |
-| `(?<=Y)X` |  Positive lookbehind | `pattern:X` if after `pattern:Y` |
-| `(?<!Y)X` | Negative lookbehind | `pattern:X` if not after `pattern:Y` |
+| `X(?=Y)`   | Mirar adelante positivo | `pattern:X` si es seguido por `pattern:Y` |
+| `X(?!Y)`   | Mirar adelante negativo | `pattern:X` si no es seguido por `pattern:Y` |
+| `(?<=Y)X` |  Mirar atras positivo | `pattern:X` si es despues de `pattern:Y` |
+| `(?<!Y)X` | Mirar atras negativo | `pattern:X` si no es despues de `pattern:Y` |

From cf7aad442d5ac1e2864c9feb3224c117f3612f99 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 16 Feb 2021 15:39:18 -0300
Subject: [PATCH 02/11] Update
 9-regular-expressions/14-regexp-lookahead-lookbehind/article.md

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 41aac98c9..5be641f98 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,6 +1,6 @@
 # mirar adelante y mirar atras
 
-A veces necesitamos buscar solo aquella coincidencia en un patron que es precedida o antecedida por otro patron.
+A veces necesitamos buscar solo aquella coincidencia en un patrón que es precedida o antecedida por otro patrón.
 
 Existe una sintaxis especial para eso, llamada "mirar adelante" y "mirar atras" (del ingles: _"lookahead" and "lookbehind"_ ) ,juntas conocidas como "mirar alrededor"
 para empezar, busquemos el precio de la cadena siguente `subject:1 pavo cuesta 30€`. eso es: un numero, seguido de `subject:€` signo  

From 618da2dcc9f4e82d1638380be8d3cee7a4d8549f Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 16 Feb 2021 15:40:34 -0300
Subject: [PATCH 03/11] Update
 9-regular-expressions/14-regexp-lookahead-lookbehind/article.md

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 5be641f98..d5d806f6a 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -3,7 +3,7 @@
 A veces necesitamos buscar solo aquella coincidencia en un patrón que es precedida o antecedida por otro patrón.
 
 Existe una sintaxis especial para eso, llamada "mirar adelante" y "mirar atras" (del ingles: _"lookahead" and "lookbehind"_ ) ,juntas conocidas como "mirar alrededor"
-para empezar, busquemos el precio de la cadena siguente `subject:1 pavo cuesta 30€`. eso es: un numero, seguido de `subject:€` signo  
+Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
 ## mirar adelante
 
 La sintaxis es: `pattern:X(?=Y)`. esto significa "mirar por `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Deben haber algun patron en lugar de `pattern:X` and `pattern:Y`.  

From 31b6fb8080dccc9ba22dec235fc668799a23cc1d Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 16 Feb 2021 15:41:16 -0300
Subject: [PATCH 04/11] Update
 9-regular-expressions/14-regexp-lookahead-lookbehind/article.md

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index d5d806f6a..b2d84ea89 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -104,7 +104,7 @@ Recuerda,`str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) r
 Pero generalmente mirar alrededor es mas conveniente.
 tipos de mirar alrededor:
 
-| Patron             | tipo             | coincidencias |
+| Patrón             | Tipo             | Coincidencias |
 |--------------------|------------------|---------|
 | `X(?=Y)`   | Mirar adelante positivo | `pattern:X` si es seguido por `pattern:Y` |
 | `X(?!Y)`   | Mirar adelante negativo | `pattern:X` si no es seguido por `pattern:Y` |

From 10718dd12ae9079adfe8b68ebbc56955cf5b0d10 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 16 Feb 2021 15:41:51 -0300
Subject: [PATCH 05/11] Update
 9-regular-expressions/14-regexp-lookahead-lookbehind/article.md

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index b2d84ea89..c3ebf9af7 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -108,5 +108,5 @@ tipos de mirar alrededor:
 |--------------------|------------------|---------|
 | `X(?=Y)`   | Mirar adelante positivo | `pattern:X` si es seguido por `pattern:Y` |
 | `X(?!Y)`   | Mirar adelante negativo | `pattern:X` si no es seguido por `pattern:Y` |
-| `(?<=Y)X` |  Mirar atras positivo | `pattern:X` si es despues de `pattern:Y` |
+| `(?<=Y)X` |  Mirar hacia atrás positivo | `pattern:X` si es después de `pattern:Y` |
 | `(?<!Y)X` | Mirar atras negativo | `pattern:X` si no es despues de `pattern:Y` |

From 0f6635c20dc6324b4d802af00d03d1b9889f585b Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 16 Feb 2021 16:18:40 -0300
Subject: [PATCH 06/11] Apply suggestions from code review

Co-authored-by: Valentiina VP <34555644+vplentinax@users.noreply.github.com>
---
 .../14-regexp-lookahead-lookbehind/article.md | 80 +++++++++----------
 1 file changed, 39 insertions(+), 41 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index c3ebf9af7..ec154bf90 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,44 +1,43 @@
-# mirar adelante y mirar atras
+# Mirar hacia delante (lookahead) y mirar hacia atrás (lookbehind)
 
 A veces necesitamos buscar solo aquella coincidencia en un patrón que es precedida o antecedida por otro patrón.
 
-Existe una sintaxis especial para eso, llamada "mirar adelante" y "mirar atras" (del ingles: _"lookahead" and "lookbehind"_ ) ,juntas conocidas como "mirar alrededor"
+Existe una sintaxis especial para eso  llamada "mirar hacia delante" y "mirar hacia atrás" (del ingles: "lookahead" y "lookbehind" ) , juntas son conocidas como "mirar alrededor" ("lookaround").
 Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
-## mirar adelante
+## Mirar hacia delante
 
-La sintaxis es: `pattern:X(?=Y)`. esto significa "mirar por `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Deben haber algun patron en lugar de `pattern:X` and `pattern:Y`.  
-Para un numero entero seguido de `subject:€`, la expresion regular sera `pattern:\d+(?=€)`:
+La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Debe haber algún patrón en lugar de `pattern:X` y `pattern:Y`.  
+Para un número entero seguido de `subject:€`, la expresión regular será `pattern:\d+(?=€)`:
 ```js run
 let str = "1 pavo cuesta 30€";
 
-alert( str.match(/\d+(?=€)/) ); // 30, el numero 1 es ignorad0, por que no tiene al lado a €
+alert( str.match(/\d+(?=€)/) ); // 30, el número 1 es ignorado, porque no está seguido de €
 ```
 
-por favor nota: el mirar adelante es solamente una prueba,lo contenido en los parentesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
-Cuando buscamos por `pattern:X(?=Y)`, el  buscador de expresion regular encuentra `pattern:X` y luego verifica si existe algun `pattern:Y` inmediatamente despues de el.Si no se cumple, entonces la posible coincidencia es omitida, y la busqueda continua.    
+Por favor tenga en cuenta: "mirar hacia delante" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
+Cuando buscamos por `pattern:X(?=Y)`, el  buscador de expresión regular encuentra `pattern:X` y luego verifica si existe algún `pattern:Y` inmediatamente después de él. Si no se cumple, entonces la posible coincidencia es omitida, y la búsqueda continua.    
 
-More complex tests are possible, e.g. `pattern:X(?=Y)(?=Z)` means:
-Pruebas mas complejas son posibles, ejemplo.`pattern:X(?=Y)(?=Z)` significa:
-1. encuentra `pattern:X`.
-2. Verifica si `pattern:Y` es inmediatamente despues de `pattern:X` (omitir si no es).
-3. Verifica si `pattern:Z` es también inmediatamente después de `pattern:X` (omitir si no es).
+Es posible realizar pruebas más complejas, e.j. `pattern:X(?=Y)(?=Z)` significa:
+1. Encuentra `pattern:X`.
+2. Verifica si `pattern:Y` está inmediatamente después de `pattern:X` (omitir si no es así).
+3. Verifica si `pattern:Z` está también inmediatamente después de `pattern:X` (omitir si no es así).
 4. Si ambos casos se cumplen, entonces el `pattern:X` es una coincidencia, de lo contrario, continúe buscando.
 
-En otras palabras, dicho patron significa que estamos buscando por `pattern:X` seguido de `pattern:Y` y `pattern:Z` al mismo tiempo. 
+En otras palabras, dicho patrón significa que estamos buscando por `pattern:X` seguido de `pattern:Y` y `pattern:Z` al mismo tiempo. 
 Eso solo es posible si los patrones `pattern:Y` y `pattern:Z` no son mutuamente exclusivos. 
-Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca por `pattern:\d+` solo si es seguido por un espacio, y si hay `30` en algun lugar despues de eso:
+Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca por `pattern:\d+` solo si es seguido por un espacio, y si hay `30` en algún lugar después de eso:
 ```js run
 let str = "1 pavo cuesta 30€";
 
 alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 ```
 
-En nuestra cadena eso coincide exactamente con el numero `1`. 
+En nuestra cadena eso coincide exactamente con el número `1`. 
 ## Mirada hacia delante negativa
 
-Digamos que queremos una cantidad, no un precio de la misma cadena.Eso es el numero `pattern:\d+`, NO seguido por `subject:€`.  
-Por eso, una mirada hacia delante negativa puede ser aplicada.
-La sintaxis es: `pattern:X(?!Y)`, la cual significa "busca `pattern:X`, pero solo si es seguido por `pattern:Y`".
+Digamos que queremos una cantidad, no un precio de la misma cadena. Eso es el número `pattern:\d+`, NO seguido por `subject:€`.  
+Por eso se puede aplicar una "mirada hacia delante negativa" ("negative lookahead").
+La sintaxis es: `pattern:X(?!Y)`, que significa "busca `pattern:X`, pero solo si no es seguido por `pattern:Y`".
 
 ```js run
 let str = "2 pavos cuestan 60€";
@@ -48,22 +47,21 @@ alert( str.match(/\d+(?!€)/) ); // 2 (el precio es omitido)
 
 ## Mirar atras
 
-Mirar adelante permite agregar a una condicion para "que sigue".
-Mirar atras es similar, pero mira detras. Eso es, permite coincidir un patron solo si hay algo antes de el.
+Mirar hacia delante permite agregar a una condicion para "lo que sigue".
+Mirar hacia atrás es similar. Es decir, permite coincidir un patrón solo si hay algo antes de el.
 La sintaxis es:
-- Mirar atras positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de el.
-- Mirar atras negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de el.
+- Mirar hacia atrás positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de el.
+- Mirar hacia atrás negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de el.
 
-Por ejemplo,cambiemos el precio a dolares estadounidenses. El signo de dollar usualmente va antes del numero, entonces miramos por `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
+Por ejemplo,cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
 ```js run
 let str = "1 pavo cuesta $30";
 
-// el signo de dolar es escapado \$
-alert( str.match(/(?<=\$)\d+/) ); // 30 (omitido el numero)
+// el signo de dólar se ha escapado \$
+alert( str.match(/(?<=\$)\d+/) ); // 30 (omitido el número)
 ```
 
-And, if we need the quantity -- a number, not preceded by `subject:$`, then we can use a negative lookbehind `pattern:(?<!\$)\d+`:
-Y, si necesitamos la cantidad -- un numero, no precedida por  `subject:$`,entonces podemos usar un mirar atras negativo `pattern:(?<!\$)\d+`: 
+Y, si necesitamos la cantidad -- un número, no precedida por  `subject:$`,entonces podemos usar mirar hacia atrás negativo `pattern:(?<!\$)\d+`: 
 ```js run
 let str = "2 pavos cuestan $60";
 
@@ -72,19 +70,19 @@ alert( str.match(/(?<!\$)\d+/) ); // 2 (precio omitido)
 
 ## Atrapando grupos
 
-Generalmente, los contenidos dentro de los parentesis de mirar alrededor no se convierten en parte del resultado.
-Ejemplo en el patron `pattern:\d+(?=€)`, el `pattern:€` signo no es capturado como parte de la coincidencia. Eso es esperado: buscamos un numero `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que deberia ser seguida por `subject:€`.
+Generalmente, los contenidos dentro de los paréntesis de "mirar alrededor" (lookaround) no se convierten en parte del resultado.
+Ejemplo en el patrón `pattern:\d+(?=€)`, el signo `pattern:€`  no es capturado como parte de la coincidencia. Eso es esperado: buscamos un número `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que debería ser seguida por `subject:€`.
 
-Pero en algunas situaciones nosotros podriamos querer el capturar la expresion mirar alrededor, o parte de ella. Eso es posible. solo hay que rodear esa parte por parentesis adicionales
+Pero en algunas situaciones nosotros podríamos querer capturar la expresión mirar alrededor, o parte de ella. Eso es posible. Solo hay que rodear esa parte por paréntesis adicionales.
 En los ejemplos de abajo el signo de divisa  `pattern:(€|kr)` es capturado, junto con la cantidad:  
 ```js run
 let str = "1 pavo cuesta 30€";
-let regexp = /\d+(?=(€|kr))/; // parentesis extra alrededor de €|kr
+let regexp = /\d+(?=(€|kr))/; // paréntesis extra alrededor de €|kr
 
 alert( str.match(regexp) ); // 30, €
 ```
 
-Y esto es lo mismo para mirar atrás:
+Y esto es lo mismo para "mirar hacia atrás":
 
 ```js run
 let str = "1 pavo cuesta $30";
@@ -95,18 +93,18 @@ alert( str.match(regexp) ); // 30, $
 
 ## Resumen
 
-Mirar adelante y mirar atras (comúnmente conocido como "mirar alrededor") son útiles cuando nos gustaría hacer coincidir algo dependiendo del contexto antes / después.
+"Mirar hacia delante" y "mirar hacia atrás" (en conjunto conocidos como "mirar alrededor") son útiles cuando nos gustaría hacer coincidir algo dependiendo del contexto antes / después.
 
-Para simples expresiones regulares podemos hacer lo mismo maualmente. Esto es:coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
+Para simples expresiones regulares podemos hacer lo mismo maualmente. Esto es: coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
 Remember, `str.match` (without flag `pattern:g`) and `str.matchAll` (always) return matches as arrays with `index` property, so we know where exactly in the text it is, and can check the context.
-Recuerda,`str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) retorna coincidencias como un arreglo con la propiedad `index`, ´pr ñp cual sabemos donde exactamente esta en el texto, y podemos verificar el contexto.
+Recuerda,`str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) retorna coincidencias como un array con la propiedad `index`,  para que sepamos exactamente dónde está en el texto, y poder comprobar el contexto.
 
-Pero generalmente mirar alrededor es mas conveniente.
-tipos de mirar alrededor:
+Pero generalmente "mirar alrededor" es más conveniente.
+Tipos de "mirar alrededor":
 
 | Patrón             | Tipo             | Coincidencias |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Mirar adelante positivo | `pattern:X` si es seguido por `pattern:Y` |
-| `X(?!Y)`   | Mirar adelante negativo | `pattern:X` si no es seguido por `pattern:Y` |
+| `X(?=Y)`   | Mirar hacia delante positivo | `pattern:X` si es seguido por `pattern:Y` |
+| `X(?!Y)`   | Mirar hacia delante negativo | `pattern:X` si no es seguido por `pattern:Y` |
 | `(?<=Y)X` |  Mirar hacia atrás positivo | `pattern:X` si es después de `pattern:Y` |
-| `(?<!Y)X` | Mirar atras negativo | `pattern:X` si no es despues de `pattern:Y` |
+| `(?<!Y)X` | Mirar hacia atrás negativo | `pattern:X` si no es después de `pattern:Y` |

From f3221719849d900afc5c6a4631721713882f677d Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Thu, 18 Feb 2021 15:44:59 -0300
Subject: [PATCH 07/11] enajenado

---
 .../14-regexp-lookahead-lookbehind/article.md | 100 +++++++++++-------
 1 file changed, 60 insertions(+), 40 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 7804f26ea..3bb2140ae 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,42 +1,54 @@
-# Mirar hacia delante (lookahead) y mirar hacia atrás (lookbehind)
+# Ver delante (lookahead) y ver detrás (lookbehind)
 
-A veces necesitamos buscar solo aquella coincidencia en un patrón que es precedida o antecedida por otro patrón.
+A veces necesitamos buscar únicamente aquellas coincidencias donde un patrón sea precedido o seguido por otro patrón.
+
+Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround").
 
-Existe una sintaxis especial para eso  llamada "mirar hacia delante" y "mirar hacia atrás" (del ingles: "lookahead" y "lookbehind" ) , juntas son conocidas como "mirar alrededor" ("lookaround").
 Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
-## Mirar hacia delante
 
-La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Debe haber algún patrón en lugar de `pattern:X` y `pattern:Y`.  
+## Ver delante
+
+La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Puede haber cualquier patrón en `pattern:X` y `pattern:Y`.
+
 Para un número entero seguido de `subject:€`, la expresión regular será `pattern:\d+(?=€)`:
+
 ```js run
 let str = "1 pavo cuesta 30€";
 
-alert( str.match(/\d+(?=€)/) ); // 30, el número 1 es ignorado, porque no está seguido de €
+alert( str.match(/\d+(?=€)/) ); // 30, el número 1 es ignorado porque no está seguido de €
 ```
 
-Por favor tenga en cuenta: "mirar hacia delante" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
-Cuando buscamos por `pattern:X(?=Y)`, el  buscador de expresión regular encuentra `pattern:X` y luego verifica si existe algún `pattern:Y` inmediatamente después de él. Si no se cumple, entonces la posible coincidencia es omitida, y la búsqueda continua.    
+Tenga en cuenta: "ver delante" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
+
+Cuando buscamos `pattern:X(?=Y)`, el motor de expresión regular encuentra `pattern:X` y luego verifica si existe `pattern:Y` inmediatamente después de él. Si no existe, entonces la coincidencia potencial es omitida y la búsqueda continúa.    
+
+Es posible realizar pruebas más complejas, por ejemplo `pattern:X(?=Y)(?=Z)` significa:
 
-Es posible realizar pruebas más complejas, e.j. `pattern:X(?=Y)(?=Z)` significa:
 1. Encuentra `pattern:X`.
-2. Verifica si `pattern:Y` está inmediatamente después de `pattern:X` (omitir si no es así).
-3. Verifica si `pattern:Z` está también inmediatamente después de `pattern:X` (omitir si no es así).
-4. Si ambos casos se cumplen, entonces el `pattern:X` es una coincidencia, de lo contrario, continúe buscando.
+2. Verifica si `pattern:Y` está inmediatamente después de `pattern:X` (omite si no es así).
+3. Verifica si `pattern:Z` está también inmediatamente después de `pattern:X` (omite si no es así).
+4. Si ambas verificaciones se cumplen, el `pattern:X` es una coincidencia. De lo contrario continúa buscando.
 
 En otras palabras, dicho patrón significa que estamos buscando por `pattern:X` seguido de `pattern:Y` y `pattern:Z` al mismo tiempo. 
-Eso solo es posible si los patrones `pattern:Y` y `pattern:Z` no son mutuamente exclusivos. 
-Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca por `pattern:\d+` solo si es seguido por un espacio, y si hay `30` en algún lugar después de eso:
+
+Eso es posible solamente si los patrones `pattern:Y` y `pattern:Z` no se excluyen mutuamente.
+
+Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca por `pattern:\d+` y reconoce coincidencia solo si es seguido por un espacio y además hay un `30` en algún lugar después del número encontrado:
+
 ```js run
 let str = "1 pavo cuesta 30€";
 
 alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 ```
 
-En nuestra cadena eso coincide exactamente con el número `1`. 
-## Mirada hacia delante negativa
+En nuestra cadena eso coincide exactamente con el número `1`.
+
+## Ver delante negativo
+
+Digamos que queremos una cantidad, no un precio de la misma cadena. Eso es el número `pattern:\d+` NO seguido por `subject:€`.
+
+Para eso se puede aplicar un "ver delante negativo" ("negative lookahead").
 
-Digamos que queremos una cantidad, no un precio de la misma cadena. Eso es el número `pattern:\d+`, NO seguido por `subject:€`.  
-Por eso se puede aplicar una "mirada hacia delante negativa" ("negative lookahead").
 La sintaxis es: `pattern:X(?!Y)`, que significa "busca `pattern:X`, pero solo si no es seguido por `pattern:Y`".
 
 ```js run
@@ -45,23 +57,27 @@ let str = "2 pavos cuestan 60€";
 alert( str.match(/\d+\b(?!€)/g) ); // 2 (el precio es omitido)
 ```
 
-## Mirar atras
+## Ver detrás
+
+"Ver delante" permite agregar una condicion para "lo que sigue".
+
+"Ver detrás" es similar. Permite coincidir un patrón solo si hay algo antes de él.
 
-Mirar hacia delante permite agregar a una condicion para "lo que sigue".
-Mirar hacia atrás es similar. Es decir, permite coincidir un patrón solo si hay algo antes de el.
 La sintaxis es:
-- Mirar hacia atrás positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de el.
-- Mirar hacia atrás negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de el.
+- Ver detrás positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de él.
+- Ver detrás negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de él.
+
+Por ejemplo, cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
 
-Por ejemplo,cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
 ```js run
 let str = "1 pavo cuesta $30";
 
 // el signo de dólar se ha escapado \$
-alert( str.match(/(?<=\$)\d+/) ); // 30 (omitido el número)
+alert( str.match(/(?<=\$)\d+/) ); // 30 (omite los números aislados)
 ```
 
-Y, si necesitamos la cantidad -- un número, no precedida por  `subject:$`,entonces podemos usar mirar hacia atrás negativo `pattern:(?<!\$)\d+`: 
+Y si necesitamos la cantidad (un número no precedida por `subject:$`), podemos usar "ver detrás negativo" `pattern:(?<!\$)\d+`: 
+
 ```js run
 let str = "2 pavos cuestan $60";
 
@@ -70,11 +86,14 @@ alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (el precio es omitido)
 
 ## Atrapando grupos
 
-Generalmente, los contenidos dentro de los paréntesis de "mirar alrededor" (lookaround) no se convierten en parte del resultado.
+Generalmente, los contenidos dentro de los paréntesis de "ver alrededor" (lookaround) no se convierten en parte del resultado.
+
 Ejemplo en el patrón `pattern:\d+(?=€)`, el signo `pattern:€`  no es capturado como parte de la coincidencia. Eso es esperado: buscamos un número `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que debería ser seguida por `subject:€`.
 
-Pero en algunas situaciones nosotros podríamos querer capturar la expresión mirar alrededor, o parte de ella. Eso es posible. Solo hay que rodear esa parte por paréntesis adicionales.
-En los ejemplos de abajo el signo de divisa  `pattern:(€|kr)` es capturado, junto con la cantidad:  
+Pero en algunas situaciones nosotros podríamos querer capturar también la expresión "ver alrededor", o parte de ella. Eso es posible. Solo hay que rodear esa parte con paréntesis adicionales.
+
+En los ejemplos de abajo el signo de divisa `pattern:(€|kr)` es capturado junto con la cantidad:  
+
 ```js run
 let str = "1 pavo cuesta 30€";
 let regexp = /\d+(?=(€|kr))/; // paréntesis extra alrededor de €|kr
@@ -82,7 +101,7 @@ let regexp = /\d+(?=(€|kr))/; // paréntesis extra alrededor de €|kr
 alert( str.match(regexp) ); // 30, €
 ```
 
-Y esto es lo mismo para "mirar hacia atrás":
+Lo mismo para "ver detrás":
 
 ```js run
 let str = "1 pavo cuesta $30";
@@ -93,18 +112,19 @@ alert( str.match(regexp) ); // 30, $
 
 ## Resumen
 
-"Mirar hacia delante" y "mirar hacia atrás" (en conjunto conocidos como "mirar alrededor") son útiles cuando nos gustaría hacer coincidir algo dependiendo del contexto antes / después.
+"Ver delante" y "ver detrás" (en conjunto conocidos como "ver alrededor") son útiles cuando queremos hacer coincidir algo dependiendo del contexto antes / después.
+
+Para expresiones regulares simples podemos hacer lo mismo manualmente. Esto es: coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
+
+Recuerda, `str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) devuelven las coincidencias como un array con la propiedad `index`, así que sabemos exactamente dónde están dentro del texto y podemos comprobar su contexto.
 
-Para simples expresiones regulares podemos hacer lo mismo maualmente. Esto es: coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
-Remember, `str.match` (without flag `pattern:g`) and `str.matchAll` (always) return matches as arrays with `index` property, so we know where exactly in the text it is, and can check the context.
-Recuerda,`str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) retorna coincidencias como un array con la propiedad `index`,  para que sepamos exactamente dónde está en el texto, y poder comprobar el contexto.
+Pero generalmente "ver alrededor" es más conveniente.
 
-Pero generalmente "mirar alrededor" es más conveniente.
-Tipos de "mirar alrededor":
+Tipos de "ver alrededor":
 
 | Patrón             | Tipo             | Coincidencias |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Mirar hacia delante positivo | `pattern:X` si es seguido por `pattern:Y` |
-| `X(?!Y)`   | Mirar hacia delante negativo | `pattern:X` si no es seguido por `pattern:Y` |
-| `(?<=Y)X` |  Mirar hacia atrás positivo | `pattern:X` si es después de `pattern:Y` |
-| `(?<!Y)X` | Mirar hacia atrás negativo | `pattern:X` si no es después de `pattern:Y` |
+| `X(?=Y)`   | Ver delante positivo | `pattern:X` si está seguido por `pattern:Y` |
+| `X(?!Y)`   | Ver delante negativo | `pattern:X` si no está seguido por `pattern:Y` |
+| `(?<=Y)X` |  Ver detrás positivo | `pattern:X` si está después de `pattern:Y` |
+| `(?<!Y)X` | Ver detrás negativo | `pattern:X` si no está después de `pattern:Y` |

From fd04542b500ec9c380a5c5c469d686f2d987a9f8 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Mar 2021 06:26:01 -0300
Subject: [PATCH 08/11] Update article.md

---
 .../14-regexp-lookahead-lookbehind/article.md        | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index b8c3020aa..e7f560a06 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -2,13 +2,13 @@
 
 A veces necesitamos buscar únicamente aquellas coincidencias donde un patrón es precedido o seguido por otro patrón.
 
-Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround").
+Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround"). Nota en español: se considera el flujo de lectura, "ahead" o "delante" es lo que tiene a la derecha (lo siguiente por leer), mientras que "behind" o "detrás" es lo que tiene a la izquierda (lo ya leido, no lo que viene "después"). 
 
 Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
 
 ## Ver delante
 
-La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero encontrar una coincidencia solo si es seguido por `pattern:Y`". Puede haber cualquier patrón en `pattern:X` y `pattern:Y`.
+La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero considerarlo una coincidencia solo si es seguido por `pattern:Y`". Puede haber cualquier patrón en `pattern:X` y `pattern:Y`.
 
 Para un número entero seguido de `subject:€`, la expresión regular será `pattern:\d+(?=€)`:
 
@@ -33,7 +33,7 @@ En otras palabras, dicho patrón significa que estamos buscando por `pattern:X`
 
 Eso es posible solamente si los patrones `pattern:Y` y `pattern:Z` no se excluyen mutuamente.
 
-Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca un `pattern:\d+` que sea seguido por un espacio y además haya un `30` en algún lugar después de él `pattern:(?=.*30)`:
+Por ejemplo, `pattern:\d+(?=\s)(?=.*30)` busca un `pattern:\d+` que sea seguido por un espacio `pattern:(?=\s)` y que también tenga un `30` en algún lugar después de él `pattern:(?=.*30)`:
 
 ```js run
 let str = "1 pavo cuesta 30€";
@@ -61,13 +61,13 @@ alert( str.match(/\d+\b(?!€)/g) ); // 2 (el precio es omitido)
 
 "Ver delante" permite agregar una condicion para "lo que sigue".
 
-"Ver detrás" es similar. Permite coincidir un patrón solo si hay algo antes de él.
+"Ver detrás" es similar. Permite coincidir un patrón solo si hay algo anterior a él.
 
 La sintaxis es:
 - Ver detrás positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de él.
 - Ver detrás negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de él.
 
-Por ejemplo, cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+` -- una cantidad precedida por `subject:$`: 
+Por ejemplo, cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+`: una cantidad precedida por `subject:$`: 
 
 ```js run
 let str = "1 pavo cuesta $30";
@@ -88,7 +88,7 @@ alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (el precio es omitido)
 
 Generalmente, los contenidos dentro de los paréntesis de "ver alrededor" (lookaround) no se convierten en parte del resultado.
 
-Ejemplo en el patrón `pattern:\d+(?=€)`, el signo `pattern:€`  no es capturado como parte de la coincidencia. Eso es esperado: buscamos un número `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que debería ser seguida por `subject:€`.
+Ejemplo en el patrón `pattern:\d+(?=€)`, el signo `pattern:€`  no es capturado como parte de la coincidencia. Eso es esperado: buscamos un número `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que indica que debe ser seguida por `subject:€`.
 
 Pero en algunas situaciones nosotros podríamos querer capturar también la expresión "ver alrededor", o parte de ella. Eso es posible. Solo hay que rodear esa parte con paréntesis adicionales.
 

From 7abc64a6f751932d41b382bc0017cc9f57e7e688 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Mar 2021 07:32:47 -0300
Subject: [PATCH 09/11] Update article.md

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

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index e7f560a06..a02ba8759 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -2,7 +2,7 @@
 
 A veces necesitamos buscar únicamente aquellas coincidencias donde un patrón es precedido o seguido por otro patrón.
 
-Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround"). Nota en español: se considera el flujo de lectura, "ahead" o "delante" es lo que tiene a la derecha (lo siguiente por leer), mientras que "behind" o "detrás" es lo que tiene a la izquierda (lo ya leido, no lo que viene "después"). 
+Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround"). 
 
 Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
 

From cc56b85661c7634d1d3bd08833fffbf94c6c6436 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 18 Jun 2021 05:17:15 -0300
Subject: [PATCH 10/11] looks

---
 .../14-regexp-lookahead-lookbehind/article.md | 44 +++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index a02ba8759..1c562e259 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -1,12 +1,12 @@
-# Ver delante (lookahead) y ver detrás (lookbehind)
+# Lookahead y lookbehind (revisar delante/detrás)
 
 A veces necesitamos buscar únicamente aquellas coincidencias donde un patrón es precedido o seguido por otro patrón.
 
-Existe una sintaxis especial para eso llamada "ver delante" y "ver detrás" (del ingles: "lookahead" y "lookbehind"), juntas son conocidas como "ver alrededor" ("lookaround"). 
+Existe una sintaxis especial para eso llamadas "lookahead" y "lookbehind" ("ver delante" y "ver detrás"), juntas son conocidas como "lookaround" ("ver alrededor"). 
 
 Para empezar, busquemos el precio de la cadena siguiente `subject:1 pavo cuesta 30€`. Eso es: un número, seguido por el signo `subject:€`.
 
-## Ver delante
+## Lookahead
 
 La sintaxis es: `pattern:X(?=Y)`. Esto significa "buscar `pattern:X`, pero considerarlo una coincidencia solo si es seguido por `pattern:Y`". Puede haber cualquier patrón en `pattern:X` y `pattern:Y`.
 
@@ -18,7 +18,7 @@ let str = "1 pavo cuesta 30€";
 alert( str.match(/\d+(?=€)/) ); // 30, el número 1 es ignorado porque no está seguido de €
 ```
 
-Tenga en cuenta: "ver delante" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
+Tenga en cuenta: "lookahead" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
 
 Cuando buscamos `pattern:X(?=Y)`, el motor de expresión regular encuentra `pattern:X` y luego verifica si existe `pattern:Y` inmediatamente después de él. Si no existe, entonces la coincidencia potencial es omitida y la búsqueda continúa.    
 
@@ -43,11 +43,11 @@ alert( str.match(/\d+(?=\s)(?=.*30)/) ); // 1
 
 En nuestra cadena eso coincide exactamente con el número `1`.
 
-## Ver delante negativo
+## Lookahead negativo
 
 Digamos que queremos una cantidad, no un precio de la misma cadena. Eso es el número `pattern:\d+` NO seguido por `subject:€`.
 
-Para eso se puede aplicar un "ver delante negativo" ("negative lookahead").
+Para eso se puede aplicar un "lookahead negativo".
 
 La sintaxis es: `pattern:X(?!Y)`, que significa "busca `pattern:X`, pero solo si no es seguido por `pattern:Y`".
 
@@ -57,15 +57,15 @@ let str = "2 pavos cuestan 60€";
 alert( str.match(/\d+\b(?!€)/g) ); // 2 (el precio es omitido)
 ```
 
-## Ver detrás
+## Lookbehind
 
-"Ver delante" permite agregar una condicion para "lo que sigue".
+"lookahead" permite agregar una condicion para "lo que sigue".
 
-"Ver detrás" es similar. Permite coincidir un patrón solo si hay algo anterior a él.
+"Lookbehind" es similar. Permite coincidir un patrón solo si hay algo anterior a él.
 
 La sintaxis es:
-- Ver detrás positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de él.
-- Ver detrás negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de él.
+- Lookbehind positivo: `pattern:(?<=Y)X`, coincide `pattern:X`, pero solo si hay `pattern:Y` antes de él.
+- Lookbehind negativo: `pattern:(?<!Y)X`, coincide `pattern:X`, pero solo si no hay `pattern:Y` antes de él.
 
 Por ejemplo, cambiemos el precio a dólares estadounidenses. El signo de dólar usualmente va antes del número, entonces para buscar `$30` usaremos `pattern:(?<=\$)\d+`: una cantidad precedida por `subject:$`: 
 
@@ -76,7 +76,7 @@ let str = "1 pavo cuesta $30";
 alert( str.match(/(?<=\$)\d+/) ); // 30 (omite los números aislados)
 ```
 
-Y si necesitamos la cantidad (un número no precedida por `subject:$`), podemos usar "ver detrás negativo" `pattern:(?<!\$)\d+`: 
+Y si necesitamos la cantidad (un número no precedida por `subject:$`), podemos usar "lookbehind negativo" `pattern:(?<!\$)\d+`: 
 
 ```js run
 let str = "2 pavos cuestan $60";
@@ -86,11 +86,11 @@ alert( str.match(/(?<!\$)\b\d+/g) ); // 2 (el precio es omitido)
 
 ## Atrapando grupos
 
-Generalmente, los contenidos dentro de los paréntesis de "ver alrededor" (lookaround) no se convierten en parte del resultado.
+Generalmente, los contenidos dentro de los paréntesis de "lookaround" (ver alrededor) no se convierten en parte del resultado.
 
 Ejemplo en el patrón `pattern:\d+(?=€)`, el signo `pattern:€`  no es capturado como parte de la coincidencia. Eso es esperado: buscamos un número `pattern:\d+`, mientras `pattern:(?=€)` es solo una prueba que indica que debe ser seguida por `subject:€`.
 
-Pero en algunas situaciones nosotros podríamos querer capturar también la expresión "ver alrededor", o parte de ella. Eso es posible. Solo hay que rodear esa parte con paréntesis adicionales.
+Pero en algunas situaciones nosotros podríamos querer capturar también la expresión en "lookaround", o parte de ella. Eso es posible: solo hay que rodear esa parte con paréntesis adicionales.
 
 En los ejemplos de abajo el signo de divisa `pattern:(€|kr)` es capturado junto con la cantidad:  
 
@@ -101,7 +101,7 @@ let regexp = /\d+(?=(€|kr))/; // paréntesis extra alrededor de €|kr
 alert( str.match(regexp) ); // 30, €
 ```
 
-Lo mismo para "ver detrás":
+Lo mismo para "lookbehind":
 
 ```js run
 let str = "1 pavo cuesta $30";
@@ -112,19 +112,19 @@ alert( str.match(regexp) ); // 30, $
 
 ## Resumen
 
-"Ver delante" y "ver detrás" (en conjunto conocidos como "ver alrededor") son útiles cuando queremos hacer coincidir algo dependiendo del contexto antes / después.
+Lookahead y lookbehind (en conjunto conocidos como "lookaround") son útiles cuando queremos hacer coincidir algo dependiendo del contexto antes/después.
 
 Para expresiones regulares simples podemos hacer lo mismo manualmente. Esto es: coincidir todo, en cualquier contexto, y luego filtrar por contexto en el bucle.
 
 Recuerda, `str.match` (sin el indicador `pattern:g`) y `str.matchAll` (siempre) devuelven las coincidencias como un array con la propiedad `index`, así que sabemos exactamente dónde están dentro del texto y podemos comprobar su contexto.
 
-Pero generalmente "ver alrededor" es más conveniente.
+Pero generalmente "lookaround" es más conveniente.
 
-Tipos de "ver alrededor":
+Tipos de "lookaround":
 
 | Patrón             | Tipo             | Coincidencias |
 |--------------------|------------------|---------|
-| `X(?=Y)`   | Ver delante positivo | `pattern:X` si está seguido por `pattern:Y` |
-| `X(?!Y)`   | Ver delante negativo | `pattern:X` si no está seguido por `pattern:Y` |
-| `(?<=Y)X` |  Ver detrás positivo | `pattern:X` si está después de `pattern:Y` |
-| `(?<!Y)X` | Ver detrás negativo | `pattern:X` si no está después de `pattern:Y` |
+| `X(?=Y)`   | lookahead positivo | `pattern:X` si está seguido por `pattern:Y` |
+| `X(?!Y)`   | lookahead negativo | `pattern:X` si no está seguido por `pattern:Y` |
+| `(?<=Y)X` | lookbehind positivo | `pattern:X` si está después de `pattern:Y` |
+| `(?<!Y)X` | lookbehind negativo | `pattern:X` si no está después de `pattern:Y` |

From 62aca343e21e45f36cb1399415de3a6d956d6fcf Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 18 Jun 2021 05:20:58 -0300
Subject: [PATCH 11/11] Update article.md

---
 .../14-regexp-lookahead-lookbehind/article.md                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
index 1c562e259..12d5376da 100644
--- a/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
+++ b/9-regular-expressions/14-regexp-lookahead-lookbehind/article.md
@@ -18,7 +18,7 @@ let str = "1 pavo cuesta 30€";
 alert( str.match(/\d+(?=€)/) ); // 30, el número 1 es ignorado porque no está seguido de €
 ```
 
-Tenga en cuenta: "lookahead" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
+Tenga en cuenta que "lookahead" es solamente una prueba, lo contenido en los paréntesis `pattern:(?=...)` no es incluido en el resultado `match:30`.
 
 Cuando buscamos `pattern:X(?=Y)`, el motor de expresión regular encuentra `pattern:X` y luego verifica si existe `pattern:Y` inmediatamente después de él. Si no existe, entonces la coincidencia potencial es omitida y la búsqueda continúa.    
 
@@ -59,7 +59,7 @@ alert( str.match(/\d+\b(?!€)/g) ); // 2 (el precio es omitido)
 
 ## Lookbehind
 
-"lookahead" permite agregar una condicion para "lo que sigue".
+"lookahead" permite agregar una condición para "lo que sigue".
 
 "Lookbehind" es similar. Permite coincidir un patrón solo si hay algo anterior a él.