From bf9ca5faffd3f70b4e51fd4f0c659332ce214738 Mon Sep 17 00:00:00 2001
From: Carlos Ortiz Gutierrez <cortizg@gmail.com>
Date: Mon, 8 Jun 2020 20:05:50 -0600
Subject: [PATCH 01/25] 9-01-ri Traducido 18
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

se agrega traducción del index del capítulo

typo
---
 .../01-regexp-introduction/article.md         | 190 +++++++++++-------
 9-regular-expressions/index.md                |   4 +-
 2 files changed, 122 insertions(+), 72 deletions(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 59775d3c0..2263321af 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -1,127 +1,177 @@
-# Patterns and flags
+# Patrones y flags
 
-Regular expressions is a powerful way of searching and replacing inside a string.
+Las expresiones regulares son patrones que proporcionan una forma poderosa de buscar y reemplazar texto.
 
-In JavaScript regular expressions are implemented using objects of a built-in `RegExp` class and integrated with strings.
+En JavaScript, están disponibles a través del objeto [RegExp](mdn:js/RegExp), además de integrarse en métodos de cadenas.
 
-Please note that regular expressions vary between programming languages. In this tutorial we concentrate on JavaScript. Of course there's a lot in common, but they are a somewhat different in Perl, Ruby, PHP etc.
+## Expresiones Regulares
 
-## Regular expressions
+Una expresión regular (también "regexp", o simplemente "reg") consiste en un *patrón* y *flags* opcionales.
 
-A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*.
+Hay dos sintaxis que se pueden usar para crear un objeto de expresión regular.
 
-There are two syntaxes to create a regular expression object.
-
-The long syntax:
+La sintaxis "larga":
 
 ```js
-regexp = new RegExp("pattern", "flags");
+regexp = new RegExp("patrón", "flags");
 ```
 
-...And the short one, using slashes `"/"`:
+Y el "corto", usando barras `"/"`:
 
 ```js
-regexp = /pattern/; // no flags
-regexp = /pattern/gmi; // with flags g,m and i (to be covered soon)
+regexp = /pattern/; // sin flags
+regexp = /pattern/gmi; // con flags g,m e i (para ser cubierto pronto)
 ```
 
-Slashes `"/"` tell JavaScript that we are creating a regular expression. They play the same role as quotes for strings.
+Las barras `pattern:/.../` le dicen a JavaScript que estamos creando una expresión regular. Juegan el mismo papel que las comillas para las cadenas.
 
-## Usage
+En ambos casos, `regexp` se convierte en una instancia de la clase incorporada `RegExp`.
 
-To search inside a string, we can use method [search](mdn:js/String/search).
+La principal diferencia entre estas dos sintaxis es que el patrón que utiliza barras `/.../` no permite que se inserten expresiones (como los literales de plantilla de cadena con `${...}`). Son completamente estáticos.
 
-Here's an example:
+Las barras se utilizan cuando conocemos la expresión regular en el momento de escribir el código, y esa es la situación más común. Mientras que  `new RegExp`, se usa con mayor frecuencia cuando necesitamos crear una expresión regular "sobre la marcha" a partir de una cadena generada dinámicamente. Por ejemplo:
 
-```js run
-let str = "I love JavaScript!"; // will search here
+```js
+let tag = prompt("¿Qué etiqueta quieres encontrar?", "h2");
 
-let regexp = /love/;
-alert( str.search(regexp) ); // 2
+igual que /<h2>/ si respondió "h2" en el mensaje anterior
 ```
 
-The `str.search` method looks for the pattern `pattern:/love/` and returns the position inside the string. As we might guess, `pattern:/love/` is the simplest possible pattern. What it does is a simple substring search.
+## Flags
 
-The code above is the same as:
+Las expresiones regulares pueden usar flags que afectan la búsqueda.
 
-```js run
-let str = "I love JavaScript!"; // will search here
+Solo hay 6 de ellas en JavaScript:
 
-let substr = 'love';
-alert( str.search(substr) ); // 2
-```
+`pattern:i`
+: Con esta flag, la búsqueda no distingue entre mayúsculas y minúsculas: no hay diferencia entre `A` y `a` (consulte el ejemplo a continuación).
+
+`pattern:g`
+: Con esta flag, la búsqueda encuentra todas las coincidencias, sin ella, solo se devuelve la primera coincidencia.
 
-So searching for `pattern:/love/` is the same as searching for `"love"`.
+`pattern:m`
+: Modo multilínea (cubierto en el capítulo <info:regexp-multiline-mode>).
 
-But that's only for now. Soon we'll create more complex regular expressions with much more searching power.
+`pattern:s`
+: Habilita el modo "dotall", que permite que un punto `pattern:.` coincida con el carácter de línea nueva `\n` (cubierto en el capítulo <info:regexp-character-classes>).
 
-```smart header="Colors"
-From here on the color scheme is:
+`pattern:u`
+: Permite el soporte completo de Unicode. La flag permite el procesamiento correcto de pares sustitutos. Más del tema en el capítulo <info:regexp-unicode>.
+
+`pattern:y`
+: Modo "adhesivo": búsqueda en la posición exacta del texto (cubierto en el capítulo <info:regexp-sticky>)
+
+```smart header="Colores"
+A partir de aquí, el esquema de color es:
 
 - regexp -- `pattern:red`
-- string (where we search) -- `subject:blue`
-- result -- `match:green`
+- cadena (donde buscamos) -- `subject:blue`
+- resulta -- `match:green`
 ```
 
+## Buscando: str.match
 
-````smart header="When to use `new RegExp`?"
-Normally we use the short syntax `/.../`. But it does not support variable insertions `${...}`.
+Como se mencionó anteriormente, las expresiones regulares se integran con los métodos de cadena.
 
-On the other hand, `new RegExp` allows to construct a pattern dynamically from a string, so it's more flexible.
+El método `str.match(regex)` busca todas las coincidencias de `regex` en la cadena `str`.
 
-Here's an example of a dynamically generated regexp:
+Tiene 3 modos de trabajo:
 
-```js run
-let tag = prompt("Which tag you want to search?", "h2");
-let regexp = new RegExp(`<${tag}>`);
+1. Si la expresión regular tiene la flag `pattern:g`, devuelve un arreglo de todas las coincidencias:
+    ```js run
+    let str = "We will, we will rock you";
 
-// finds <h2> by default
-alert( "<h1> <h2> <h3>".search(regexp));
-```
-````
+    alert( str.match(/we/gi) ); // We,we (un arreglo de 2 subcadenas que coinciden)
+    ```
+    Tenga en cuenta que tanto `match:We` como `match: we` se encuentran, porque la flag `pattern:i` hace que la expresión regular no distinga entre mayúsculas y minúsculas.
 
+2. Si no existe dicha flag, solo devuelve la primera coincidencia en forma de arreglo, con la coincidencia completa en el índice `0` y algunos detalles adicionales en las propiedades:
+    ```js run
+    let str = "We will, we will rock you";
 
-## Flags
+    let result = str.match(/we/i); // sin la flag g
+
+    alert( result[0] );     // We (1ra coincidencia)
+    alert( result.length ); // 1
 
-Regular expressions may have flags that affect the search.
+    // Details:
+    alert( result.index );  // 0 (posición de la coincidencia)
+    alert( result.input );  // We will, we will rock you (cadena fuente)
+    ```
+    El arreglo puede tener otros índices, además de `0` si una parte de la expresión regular está encerrada entre paréntesis. Cubriremos eso en el capítulo <info:regexp-groups>.
 
-There are only 5 of them in JavaScript:
+3. Y, finalmente, si no hay coincidencias, se devuelve `null` (no importa si hay una flag `pattern:g` o no).
 
-`i`
-: With this flag the search is case-insensitive: no difference between `A` and `a` (see the example below).
+    Este es un matiz muy importante. Si no hay coincidencias, no recibimos un arreglo vacío, sino que recibimos `null`. Olvidar eso puede conducir a errores, por ejemplo:
 
-`g`
-: With this flag the search looks for all matches, without it -- only the first one (we'll see uses in the next chapter).
+    ```js run
+    let matches = "JavaScript".match(/HTML/); // = null
 
-`m`
-: Multiline mode (covered in the chapter <info:regexp-multiline-mode>).
+    if (!matches.length) { // Error: No se puede leer la propiedad 'length' de null
+      alert("Error en la línea anterior");
+    }
+    ```
 
-`s`
-: "Dotall" mode, allows `.` to match newlines (covered in the chapter <info:regexp-character-classes>).
+    Si queremos que el resultado sea siempre un arreglo, podemos escribirlo de esta manera:
 
-`u`
-: Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter <info:regexp-unicode>.
+    ```js run
+    let matches = "JavaScript".match(/HTML/)*!* || []*/!*;
 
-`y`
-: Sticky mode (covered in the chapter <info:regexp-sticky>)
+    if (!matches.length) {
+      alert("Sin coincidencias"); // ahora si trabaja
+    }
+    ```
 
-We'll cover all these flags further in the tutorial.
+## Reemplazando: str.replace
 
-For now, the simplest flag is `i`, here's an example:
+El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` en la cadena `str` con `replacement` (todas las coincidencias si está la flag `pattern:g`, de lo contrario, solo la primera).
+
+Por ejemplo:
+
+```js run
+// sin la flag g
+alert( "We will, we will".replace(/we/i, "I") ); // I will, we will
+
+// con la flag g
+alert( "We will, we will".replace(/we/ig, "I") ); // I will, I will
+```
+
+El segundo argumento es la cadena de `reemplazo`. Podemos usar combinaciones de caracteres especiales para insertar fragmentos de la coincidencia:
+
+| Símbolos | Acción en la cadena de reemplazo |
+|--------|--------|
+|`$&`|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 número de 1-2 dígitos, entonces inserta el contenido de los paréntesis n-ésimo, más del tema en el capítulo <info:regexp-groups>|
+|`$<name>`|inserta el contenido de los paréntesis con el `nombre` dado, más del tema en el capítulo <info:regexp-groups>|
+|`$$`|inserta el carácter `$` |
+
+Un ejemplo con `pattern:$&`:
 
 ```js run
-let str = "I love JavaScript!";
+alert( "Me gusta HTML".replace(/HTML/, "$& y JavaScript") ); // Me gusta HTML y JavaScript
+```
 
-alert( str.search(/LOVE/i) ); // 2 (found lowercased)
+## Pruebas: regexp.test
+
+El método `regexp.test(str)` busca al menos una coincidencia, si se encuentra, devuelve `true`, de lo contrario `false`.
+
+```js run
+let str = "Me gusta JavaScript";
+let regexp = /GUSTA/i;
 
-alert( str.search(/LOVE/) ); // -1 (nothing found without 'i' flag)
+alert( regexp.test(str) ); // true
 ```
 
-So the `i` flag already makes regular expressions more powerful than a simple substring search. But there's so much more. We'll cover other flags and features in the next chapters.
+Más adelante en este capítulo estudiaremos más expresiones regulares, exploraremos más ejemplos y también conoceremos otros métodos.
 
+La información completa sobre métodos se proporciona en el artículo <info:regexp-method>.
 
-## Summary
+## Resumen
 
-- A regular expression consists of a pattern and optional flags: `g`, `i`, `m`, `u`, `s`, `y`.
-- Without flags and special symbols that we'll study later, the search by a regexp is the same as a  substring search.
-- The method `str.search(regexp)` returns the index where the match is found or `-1` if there's no match. In the next chapter we'll see other methods.
+- Una expresión regular consiste en un patrón y flags opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
+- Sin flags y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
+- El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una flag `pattern:g`, de lo contrario, solo la primera.
+- El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una flag `pattern:g`, de lo contrario solo la primera.
+- El método `regexp.test(str)` devuelve `true` si hay al menos una coincidencia, de lo contrario, devuelve `false`.
diff --git a/9-regular-expressions/index.md b/9-regular-expressions/index.md
index ac25aaa67..afe590b4f 100644
--- a/9-regular-expressions/index.md
+++ b/9-regular-expressions/index.md
@@ -1,3 +1,3 @@
-# Regular expressions
+# Expresiones Regulares
 
-Regular expressions is a powerful way of doing search and replace in strings.
+Las expresiones regulares son una forma poderosa de hacer búsqueda y reemplazo de cadenas.

From cbb314c15b31439a12b25bf93c4215203fa950f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 13:59:35 -0600
Subject: [PATCH 02/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 2263321af..52a2d2054 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -1,4 +1,4 @@
-# Patrones y flags
+# Patrones y banderas (flags)
 
 Las expresiones regulares son patrones que proporcionan una forma poderosa de buscar y reemplazar texto.
 

From f8f5b4290a43ab7eb52fb3760d90ed7c77a91849 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 13:59:51 -0600
Subject: [PATCH 03/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 52a2d2054..db4fb3a74 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -6,7 +6,7 @@ En JavaScript, están disponibles a través del objeto [RegExp](mdn:js/RegExp),
 
 ## Expresiones Regulares
 
-Una expresión regular (también "regexp", o simplemente "reg") consiste en un *patrón* y *flags* opcionales.
+Una expresión regular (también "regexp", o simplemente "reg") consiste en un *patrón* y *banderas* opcionales.
 
 Hay dos sintaxis que se pueden usar para crear un objeto de expresión regular.
 

From 70ef3267cfb9ee88c1c1d854462ca0867b1cb555 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:00:00 -0600
Subject: [PATCH 04/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index db4fb3a74..ab8d07bc2 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -19,7 +19,7 @@ regexp = new RegExp("patrón", "flags");
 Y el "corto", usando barras `"/"`:
 
 ```js
-regexp = /pattern/; // sin flags
+regexp = /pattern/; // sin banderas
 regexp = /pattern/gmi; // con flags g,m e i (para ser cubierto pronto)
 ```
 

From d3bc30b6d851751a3ceaa009b8e9c254d64b1628 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:00:17 -0600
Subject: [PATCH 05/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index ab8d07bc2..f76ef0c29 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -37,7 +37,7 @@ let tag = prompt("¿Qué etiqueta quieres encontrar?", "h2");
 igual que /<h2>/ si respondió "h2" en el mensaje anterior
 ```
 
-## Flags
+## Banderas
 
 Las expresiones regulares pueden usar flags que afectan la búsqueda.
 

From fd70dcd9b2f8043e154c69eb14d247294abbf98d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:00:28 -0600
Subject: [PATCH 06/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index f76ef0c29..ed0328e33 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -170,7 +170,7 @@ La información completa sobre métodos se proporciona en el artículo <info:reg
 
 ## Resumen
 
-- Una expresión regular consiste en un patrón y flags opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
+- Una expresión regular consiste en un patrón y banderas opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
 - Sin flags y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
 - El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una flag `pattern:g`, de lo contrario, solo la primera.
 - El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una flag `pattern:g`, de lo contrario solo la primera.

From 056e5448bcbb14d4482230b59db2a7854d751408 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:00:37 -0600
Subject: [PATCH 07/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index ed0328e33..a379139c3 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -172,6 +172,6 @@ La información completa sobre métodos se proporciona en el artículo <info:reg
 
 - Una expresión regular consiste en un patrón y banderas opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
 - Sin flags y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
-- El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una flag `pattern:g`, de lo contrario, solo la primera.
+- El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una bandera `pattern:g`, de lo contrario, solo la primera.
 - El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una flag `pattern:g`, de lo contrario solo la primera.
 - El método `regexp.test(str)` devuelve `true` si hay al menos una coincidencia, de lo contrario, devuelve `false`.

From 5dea5ad68da88542e38e0e82044247126fb1b5c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:00:51 -0600
Subject: [PATCH 08/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index a379139c3..0e4a84ba1 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -173,5 +173,5 @@ La información completa sobre métodos se proporciona en el artículo <info:reg
 - Una expresión regular consiste en un patrón y banderas opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
 - Sin flags y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
 - El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una bandera `pattern:g`, de lo contrario, solo la primera.
-- El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una flag `pattern:g`, de lo contrario solo la primera.
+- El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una bandera `pattern:g`, de lo contrario solo la primera.
 - El método `regexp.test(str)` devuelve `true` si hay al menos una coincidencia, de lo contrario, devuelve `false`.

From e33ec5bac67ed26440310afa1d724bbaf429e8bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:01:00 -0600
Subject: [PATCH 09/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 0e4a84ba1..46e7a75a9 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -171,7 +171,7 @@ La información completa sobre métodos se proporciona en el artículo <info:reg
 ## Resumen
 
 - Una expresión regular consiste en un patrón y banderas opcionales: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`.
-- Sin flags y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
+- Sin banderas y símbolos especiales (que estudiaremos más adelante), la búsqueda por expresión regular es lo mismo que una búsqueda de subcadena.
 - El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una bandera `pattern:g`, de lo contrario, solo la primera.
 - El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una bandera `pattern:g`, de lo contrario solo la primera.
 - El método `regexp.test(str)` devuelve `true` si hay al menos una coincidencia, de lo contrario, devuelve `false`.

From eba3900f7c64b75de0b69fad3d896c4d34830ac8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:01:11 -0600
Subject: [PATCH 10/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 46e7a75a9..96354d4d3 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -20,7 +20,7 @@ Y el "corto", usando barras `"/"`:
 
 ```js
 regexp = /pattern/; // sin banderas
-regexp = /pattern/gmi; // con flags g,m e i (para ser cubierto pronto)
+regexp = /pattern/gmi; // con banderas g,m e i (para ser cubierto pronto)
 ```
 
 Las barras `pattern:/.../` le dicen a JavaScript que estamos creando una expresión regular. Juegan el mismo papel que las comillas para las cadenas.

From 550039ec3d7fa369d031eb1d15f4dfeb5750ebd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:01:27 -0600
Subject: [PATCH 11/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 96354d4d3..698af685a 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -44,7 +44,7 @@ Las expresiones regulares pueden usar flags que afectan la búsqueda.
 Solo hay 6 de ellas en JavaScript:
 
 `pattern:i`
-: Con esta flag, la búsqueda no distingue entre mayúsculas y minúsculas: no hay diferencia entre `A` y `a` (consulte el ejemplo a continuación).
+: Con esta bandera, la búsqueda no distingue entre mayúsculas y minúsculas: no hay diferencia entre `A` y `a` (consulte el ejemplo a continuación).
 
 `pattern:g`
 : Con esta flag, la búsqueda encuentra todas las coincidencias, sin ella, solo se devuelve la primera coincidencia.

From 834ac1a5740ce8a4652ad0fe72c16202f632aa54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:01:42 -0600
Subject: [PATCH 12/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 698af685a..bdf85b251 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -39,7 +39,7 @@ igual que /<h2>/ si respondió "h2" en el mensaje anterior
 
 ## Banderas
 
-Las expresiones regulares pueden usar flags que afectan la búsqueda.
+Las expresiones regulares pueden usar banderas que afectan la búsqueda.
 
 Solo hay 6 de ellas en JavaScript:
 

From 31afb25b91600f7a728269560b93ad111b0b0537 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:01:57 -0600
Subject: [PATCH 13/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index bdf85b251..a4fee09e1 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -47,7 +47,7 @@ Solo hay 6 de ellas en JavaScript:
 : Con esta bandera, la búsqueda no distingue entre mayúsculas y minúsculas: no hay diferencia entre `A` y `a` (consulte el ejemplo a continuación).
 
 `pattern:g`
-: Con esta flag, la búsqueda encuentra todas las coincidencias, sin ella, solo se devuelve la primera coincidencia.
+: Con esta bandera, la búsqueda encuentra todas las coincidencias, sin ella, solo se devuelve la primera coincidencia.
 
 `pattern:m`
 : Modo multilínea (cubierto en el capítulo <info:regexp-multiline-mode>).

From 44e59d9dbca10f20db1c7a6478be37b7ec3068d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:02:09 -0600
Subject: [PATCH 14/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index a4fee09e1..bd7471bfc 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -13,7 +13,7 @@ Hay dos sintaxis que se pueden usar para crear un objeto de expresión regular.
 La sintaxis "larga":
 
 ```js
-regexp = new RegExp("patrón", "flags");
+regexp = new RegExp("patrón", "banderas");
 ```
 
 Y el "corto", usando barras `"/"`:

From 9c34e0758f91f574e48d7abb5c029b9d5d413c79 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:03:26 -0600
Subject: [PATCH 15/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index bd7471bfc..0e333857e 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -56,7 +56,7 @@ Solo hay 6 de ellas en JavaScript:
 : Habilita el modo "dotall", que permite que un punto `pattern:.` coincida con el carácter de línea nueva `\n` (cubierto en el capítulo <info:regexp-character-classes>).
 
 `pattern:u`
-: Permite el soporte completo de Unicode. La flag permite el procesamiento correcto de pares sustitutos. Más del tema en el capítulo <info:regexp-unicode>.
+: Permite el soporte completo de Unicode. La bandera permite el procesamiento correcto de pares sustitutos. Más del tema en el capítulo <info:regexp-unicode>.
 
 `pattern:y`
 : Modo "adhesivo": búsqueda en la posición exacta del texto (cubierto en el capítulo <info:regexp-sticky>)

From 43196a1cb7592f3df0613e535cceb32338b02006 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:03:57 -0600
Subject: [PATCH 16/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 0e333857e..018323374 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -77,7 +77,7 @@ El método `str.match(regex)` busca todas las coincidencias de `regex` en la cad
 
 Tiene 3 modos de trabajo:
 
-1. Si la expresión regular tiene la flag `pattern:g`, devuelve un arreglo de todas las coincidencias:
+1. Si la expresión regular tiene la bandera `pattern:g`, devuelve un arreglo de todas las coincidencias:
     ```js run
     let str = "We will, we will rock you";
 

From b285a9e647c95ee779667290dd8a1e44a44bd859 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:04:20 -0600
Subject: [PATCH 17/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 018323374..564a3c07f 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -83,7 +83,7 @@ Tiene 3 modos de trabajo:
 
     alert( str.match(/we/gi) ); // We,we (un arreglo de 2 subcadenas que coinciden)
     ```
-    Tenga en cuenta que tanto `match:We` como `match: we` se encuentran, porque la flag `pattern:i` hace que la expresión regular no distinga entre mayúsculas y minúsculas.
+    Tenga en cuenta que tanto `match:We` como `match: we` se encuentran, porque la bandera `pattern:i` hace que la expresión regular no distinga entre mayúsculas y minúsculas.
 
 2. Si no existe dicha flag, solo devuelve la primera coincidencia en forma de arreglo, con la coincidencia completa en el índice `0` y algunos detalles adicionales en las propiedades:
     ```js run

From d8e9a5407481e9ca775582a6ff14218eb1d57c1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:04:33 -0600
Subject: [PATCH 18/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 564a3c07f..268960966 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -85,7 +85,7 @@ Tiene 3 modos de trabajo:
     ```
     Tenga en cuenta que tanto `match:We` como `match: we` se encuentran, porque la bandera `pattern:i` hace que la expresión regular no distinga entre mayúsculas y minúsculas.
 
-2. Si no existe dicha flag, solo devuelve la primera coincidencia en forma de arreglo, con la coincidencia completa en el índice `0` y algunos detalles adicionales en las propiedades:
+2. Si no existe dicha bandera, solo devuelve la primera coincidencia en forma de arreglo, con la coincidencia completa en el índice `0` y algunos detalles adicionales en las propiedades:
     ```js run
     let str = "We will, we will rock you";
 

From b992920fae1de65ada0fb8e80bfb9815308015e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:04:50 -0600
Subject: [PATCH 19/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 268960966..65a27d0f2 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -100,7 +100,7 @@ Tiene 3 modos de trabajo:
     ```
     El arreglo puede tener otros índices, además de `0` si una parte de la expresión regular está encerrada entre paréntesis. Cubriremos eso en el capítulo <info:regexp-groups>.
 
-3. Y, finalmente, si no hay coincidencias, se devuelve `null` (no importa si hay una flag `pattern:g` o no).
+3. Y, finalmente, si no hay coincidencias, se devuelve `null` (no importa si hay una bandera `pattern:g` o no).
 
     Este es un matiz muy importante. Si no hay coincidencias, no recibimos un arreglo vacío, sino que recibimos `null`. Olvidar eso puede conducir a errores, por ejemplo:
 

From 98c112e1d8db466ab66ad32c13014d0c7ae8cacf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:05:53 -0600
Subject: [PATCH 20/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 65a27d0f2..7cdea6bf1 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -89,7 +89,7 @@ Tiene 3 modos de trabajo:
     ```js run
     let str = "We will, we will rock you";
 
-    let result = str.match(/we/i); // sin la flag g
+    let result = str.match(/we/i); // sin la bandera g
 
     alert( result[0] );     // We (1ra coincidencia)
     alert( result.length ); // 1

From e33144edb4063e56e238561b7bdb67839ef15a2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:06:05 -0600
Subject: [PATCH 21/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 7cdea6bf1..e19b71ec3 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -94,7 +94,7 @@ Tiene 3 modos de trabajo:
     alert( result[0] );     // We (1ra coincidencia)
     alert( result.length ); // 1
 
-    // Details:
+    // Detalles:
     alert( result.index );  // 0 (posición de la coincidencia)
     alert( result.input );  // We will, we will rock you (cadena fuente)
     ```

From ee79bcda85a1b1c7a6d8c2a0be84bbc29b42beb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:06:19 -0600
Subject: [PATCH 22/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index e19b71ec3..cdeb67b95 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -124,7 +124,7 @@ Tiene 3 modos de trabajo:
 
 ## Reemplazando: str.replace
 
-El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` en la cadena `str` con `replacement` (todas las coincidencias si está la flag `pattern:g`, de lo contrario, solo la primera).
+El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` en la cadena `str` con `replacement` (todas las coincidencias si está la bandera `pattern:g`, de lo contrario, solo la primera).
 
 Por ejemplo:
 

From dfab9afc62c97f27bc6ec6203f16fc9c599b5210 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:06:33 -0600
Subject: [PATCH 23/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index cdeb67b95..c21747ee8 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -129,7 +129,7 @@ El método `str.replace(regexp, replacement)` reemplaza las coincidencias encont
 Por ejemplo:
 
 ```js run
-// sin la flag g
+// sin la bandera g
 alert( "We will, we will".replace(/we/i, "I") ); // I will, we will
 
 // con la flag g

From 90232f0bb6223014e99e1bae18c047e67c3ed379 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:06:46 -0600
Subject: [PATCH 24/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

Co-authored-by: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
---
 9-regular-expressions/01-regexp-introduction/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index c21747ee8..a14d25fa5 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -132,7 +132,7 @@ Por ejemplo:
 // sin la bandera g
 alert( "We will, we will".replace(/we/i, "I") ); // I will, we will
 
-// con la flag g
+// con la bandera g
 alert( "We will, we will".replace(/we/ig, "I") ); // I will, I will
 ```
 

From 63d4eb523155f91279e059dd134612fc9c840572 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Ortiz=20Guti=C3=A9rrez?=
 <56600925+cortizg@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:17:10 -0600
Subject: [PATCH 25/25] Update
 9-regular-expressions/01-regexp-introduction/article.md

---
 9-regular-expressions/01-regexp-introduction/article.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md
index 0339d2612..34b36ddf7 100644
--- a/9-regular-expressions/01-regexp-introduction/article.md
+++ b/9-regular-expressions/01-regexp-introduction/article.md
@@ -138,7 +138,7 @@ alert( "We will, we will".replace(/we/i, "I") ); // I will, we will
 alert( "We will, we will".replace(/we/ig, "I") ); // I will, I will
 ```
 
-El segundo argumento es la cadena de `reemplazo`. Podemos usar combinaciones de caracteres especiales para insertar fragmentos de la coincidencia:
+El segundo argumento es la cadena de `replacement`. Podemos usar combinaciones de caracteres especiales para insertar fragmentos de la coincidencia:
 
 | Símbolos | Acción en la cadena de reemplazo |
 |--------|--------|
@@ -178,4 +178,3 @@ La información completa sobre métodos se proporciona en el artículo <info:reg
 - El método `str.match(regexp)` busca coincidencias: devuelve todas si hay una bandera `pattern:g`, de lo contrario, solo la primera.
 - El método `str.replace(regexp, replacement)` reemplaza las coincidencias encontradas usando `regexp` con `replacement`: devuelve todas si hay una bandera `pattern:g`, de lo contrario solo la primera.
 - El método `regexp.test(str)` devuelve `true` si hay al menos una coincidencia, de lo contrario, devuelve `false`.
-

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/javascript-tutorial/es.javascript.info/pull/237.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/javascript-tutorial/es.javascript.info/pull/237.patch" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/javascript-tutorial/es.javascript.info/pull/237.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/javascript-tutorial/es.javascript.info/pull/237.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>