Mar 10, 2021 · Feb 15, 2021 · Feb 15, 2021
diff --git a/9-regular-expressions/16-regexp-sticky/article.md b/9-regular-expressions/16-regexp-sticky/article.md

 EL indicador `pattern:y` permite realizar la búsqueda en una posición dada en el string de origen.

 Para entender el caso de uso del indicador `pattern:y`, y ver lo notable que es, exploremos un ejemplo práctico.
 Para entender el caso de uso del indicador `pattern:y` exploremos un ejemplo práctico.

 Una tarea común para regexps es el "Análisis léxico": tenemos un texto, por ej. en un lenguaje de programación, y analiza sus elementos estructurales.

 Por ejemplo, HTML tiene etiquetas y atributos, el código JavaScript tiene funciones, variables, etc.
 Una tarea común para regexps es el "Análisis léxico": tomar un texto (como el de un lenguaje de programación), y analizar sus elementos estructurales. Por ejemplo, HTML tiene etiquetas y atributos, el código JavaScript tiene funciones, variables, etc.

 Escribir analizadores léxicos es un área especial, con sus propias herramientas y algoritmos, así que no profundizaremos en ello; pero existe una tarea común: leer algo en una posición dada.

 Por ej. tenemos una cadena de código `subject:let varName = "value"`, y necesitamos leer el nombre de su variable, que comienza en la posición `4`.

 Buscaremos el nombre de la variable usando regexp `pattern:\w+`. En realidad, el nombre de la variable de JavaScript necesita un regexp un poco más complejo para un emparejamiento más preciso, pero aquí eso no importa.

 Una llamada a `str.match(/\w+/)` solo encontrará la primera palabra de la línea, o todas las palabras con el indicador `pattern:g`. Pero solo necesitamos una palabra en la posición `4`.
 Una llamada a `str.match(/\w+/)` solo encontrará la primera palabra de la línea (`let`). No es la que queremos.
 Podríamos añadir el indicador `pattern:g`, pero al llamar a `str.match(/\w+/g)` buscará todas las palabras del texto y solo necesitamos una y en la posición `4`. De nuevo, no es lo que necesitamos.

 **Entonces, ¿cómo buscamos exactamente en un posición deterninada?**

 Para buscar desde la posición dada, usamos el método `regexp.exec(str)`.
 Usemos el método `regexp.exec(str)`.

 Sí`regexp`no tiene indicadores `pattern:g`o `pattern:y`,entonceseste método busca la primera coincidenciaen el string `str`,exactamentecomo`str.match(regexp)`. Un caso tan simple sin indicadores no nos interesa aquí.
 Para un`regexp`sin los indicadores `pattern:g`y `pattern:y`, este método busca la primera coincidenciay funcionaexactamenteigual a`str.match(regexp)`.

 Siexiste el indicador `pattern:g`, realiza la búsqueda enel string`str` empezando desde la posición almacenada en su propiedad `regexp.lastIndex`. Y si encuentra una coincidencia, establece `regexp.lastIndex` en el index inmediatamentedespués del emparejamiento.
 ...Pero siexiste el indicador `pattern:g`, realiza la búsqueda en `str` empezando desde la posición almacenada en su propiedad `regexp.lastIndex`. Y si encuentra una coincidencia, establece `regexp.lastIndex` en el index inmediatamenteposterior a la coincidencia.

 Cuando un regex es creado, su `lastIndex`es `0`.
 En otras palabras, `regexp.lastIndex`funciona como punto de partida para la búsqueda, cada llamada lo reestablece a un nuevo valor: el posterior a la última coincidencia.

 Entonces, llamadas sucesivas a `regexp.exec(str)` devuelve coincidencias una después de la otra.

 Un ejemplo (con el indicador `pattern:g`):

 ```js run
 let str = 'let varName';

 let str = 'let varName'; // encontremos todas las palabras del string
 let regexp = /\w+/g;

 alert(regexp.lastIndex); // 0 (inicialmente lastIndex=0)

 let word1 = regexp.exec(str);
 alert(word1[0]); // let (primera palabra)
 alert(regexp.lastIndex); // 3 (Posición posterioral emparejamiento)
 alert(regexp.lastIndex); // 3 (Posición posteriora la coincidencia)

 let word2 = regexp.exec(str);
 alert(word2[0]); // varName (2da palabra)
 alert(regexp.lastIndex); // 11 (Posición posterioral emparejamiento)
 alert(regexp.lastIndex); // 11 (Posición posteriora la coincidencia)

 let word3 = regexp.exec(str);
 alert(word3); // null (no másemparejamientos)
 alert(regexp.lastIndex); // 0 (reiniciaen el final de la búsqueda)
 alert(word3); // null (no máscoincidencias)
 alert(regexp.lastIndex); // 0 (sereiniciaal final de la búsqueda)
 ```

 Cada coincidencia es devuelta como un array con grupos y propiedades adicionales.

 Podemos conseguir todas las coincidencias en el loop:

 ```js run
 }
 ```

 Tal uso de `regexp.exec` es una alternativa al método `str.match bAll`.
 Tal uso de `regexp.exec` es una alternativa al método `str.match bAll`, con más control sobre el proceso.

 A diferencia de otros métodos, podemos establecer nuestro propio `lastIndex`, para comenzar la búsqueda desde la posición dada.
 Volvamos a nuestra tarea.

 Por ejemplo, encontremos una palabra, comenzando desde la posición `4`:
 Podemos estableceer manualmente `lastIndex` a `4`, para comenzar la búsqueda desde la posición dada.

 Como aquí:

 ```js run
 let str = 'let varName = "value"';
 alert(word); // varName
 ```

 ¡Problema resuelto!

 Realizamos una búsqueda de `pattern:\w+`, comenzando desde la posición `regexp.lastIndex = 4`.

 El resultado es correcto.

 ...Pero espera, no tan rápido.

 Nota que la búsqueda comienza en la posición `lastIndex` y luego sigue adelante. Si no hay ninguna palabra en la posición `lastIndex` pero la hay en algún lugar posterior, entonces será encontrada:

 ```js run
 let regexp = /\w+/g;

 *!*
 // comenzando desde la posición 3
 regexp.lastIndex = 3;
 */!*

 let word = regexp.exec(str);
 // encuentra coincidencia en la posición 4
 alert(word[0]); // varName
 alert(word.index); // 4
 ```

 ...Así que, con la propiedad `lastIndex` del indicador `pattern:g` se establecela posicióninicial de la búsqueda.
 Para algunas tareas, incluido el análisis léxico, esto está mal. Necesitamos la coincidencia enla posiciónexacta, y para ello es el flag `y`.

 **El indicador `pattern:y` hace que `regexp.exec` busque exactamente en la posición `lastIndex`,ni antes ni después.**
 **El indicador `pattern:y` hace que `regexp.exec` busque"exactamente en" la posición `lastIndex`,no "comenzando en" ella.**

 Aquí está la misma búsqueda con el indicador `pattern:y`:


 Como podemos ver, el `pattern:/\w+/y` de regexp no coincide en la posición `3` (a diferencia del indicador `pattern:g`), pero coincide en la posición `4`.

 No solamente es lo que necesitamos, el uso del indicador `pattern:y` mejora el rendimiento.

 Imagina que tenemos un texto largo, y no hay coincidencias en él. Entonces la búsqueda con el indicador `pattern:g` irá hasta el final del texto, y esto tomará significativamente más tiempo que la búsqueda con el indicador `pattern:y`.

 En tareas tales como el análisis léxico, normalmente hay muchas búsquedas en una posición exacta. Usar el indicador `pattern:y` es la clave para un buen desempeño.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,53 +3,52 @@

		EL indicador `pattern:y` permite realizar la búsqueda en una posición dada en el string de origen.

		Para entender el caso de uso del indicador `pattern:y`, y ver lo notable que es, exploremos un ejemplo práctico.
		Para entender el caso de uso del indicador `pattern:y` exploremos un ejemplo práctico.

		Una tarea común para regexps es el "Análisis léxico": tenemos un texto, por ej. en un lenguaje de programación, y analiza sus elementos estructurales.

		Por ejemplo, HTML tiene etiquetas y atributos, el código JavaScript tiene funciones, variables, etc.
		Una tarea común para regexps es el "Análisis léxico": tomar un texto (como el de un lenguaje de programación), y analizar sus elementos estructurales. Por ejemplo, HTML tiene etiquetas y atributos, el código JavaScript tiene funciones, variables, etc.

		Escribir analizadores léxicos es un área especial, con sus propias herramientas y algoritmos, así que no profundizaremos en ello; pero existe una tarea común: leer algo en una posición dada.

		Por ej. tenemos una cadena de código `subject:let varName = "value"`, y necesitamos leer el nombre de su variable, que comienza en la posición `4`.

		Buscaremos el nombre de la variable usando regexp `pattern:\w+`. En realidad, el nombre de la variable de JavaScript necesita un regexp un poco más complejo para un emparejamiento más preciso, pero aquí eso no importa.

		Una llamada a `str.match(/\w+/)` solo encontrará la primera palabra de la línea, o todas las palabras con el indicador `pattern:g`. Pero solo necesitamos una palabra en la posición `4`.
		Una llamada a `str.match(/\w+/)` solo encontrará la primera palabra de la línea (`let`). No es la que queremos.
		Podríamos añadir el indicador `pattern:g`, pero al llamar a `str.match(/\w+/g)` buscará todas las palabras del texto y solo necesitamos una y en la posición `4`. De nuevo, no es lo que necesitamos.

		Entonces, ¿cómo buscamos exactamente en un posición deterninada?

		Para buscar desde la posición dada, usamos el método `regexp.exec(str)`.
		Usemos el método `regexp.exec(str)`.

		Sí`regexp`no tiene indicadores `pattern:g`o `pattern:y`,entonceseste método busca la primera coincidenciaen el string `str`,exactamentecomo`str.match(regexp)`. Un caso tan simple sin indicadores no nos interesa aquí.
		Para un`regexp`sin los indicadores `pattern:g`y `pattern:y`, este método busca la primera coincidenciay funcionaexactamenteigual a`str.match(regexp)`.

		Siexiste el indicador `pattern:g`, realiza la búsqueda enel string`str` empezando desde la posición almacenada en su propiedad `regexp.lastIndex`. Y si encuentra una coincidencia, establece `regexp.lastIndex` en el index inmediatamentedespués del emparejamiento.
		...Pero siexiste el indicador `pattern:g`, realiza la búsqueda en `str` empezando desde la posición almacenada en su propiedad `regexp.lastIndex`. Y si encuentra una coincidencia, establece `regexp.lastIndex` en el index inmediatamenteposterior a la coincidencia.

		Cuando un regex es creado, su `lastIndex`es `0`.
		En otras palabras, `regexp.lastIndex`funciona como punto de partida para la búsqueda, cada llamada lo reestablece a un nuevo valor: el posterior a la última coincidencia.

		Entonces, llamadas sucesivas a `regexp.exec(str)` devuelve coincidencias una después de la otra.

		Un ejemplo (con el indicador `pattern:g`):

		```js run
		let str = 'let varName';

		let str = 'let varName'; // encontremos todas las palabras del string
		let regexp = /\w+/g;

		alert(regexp.lastIndex); // 0 (inicialmente lastIndex=0)

		let word1 = regexp.exec(str);
		alert(word1[0]); // let (primera palabra)
		alert(regexp.lastIndex); // 3 (Posición posterioral emparejamiento)
		alert(regexp.lastIndex); // 3 (Posición posteriora la coincidencia)

		let word2 = regexp.exec(str);
		alert(word2[0]); // varName (2da palabra)
		alert(regexp.lastIndex); // 11 (Posición posterioral emparejamiento)
		alert(regexp.lastIndex); // 11 (Posición posteriora la coincidencia)

		let word3 = regexp.exec(str);
		alert(word3); // null (no másemparejamientos)
		alert(regexp.lastIndex); // 0 (reiniciaen el final de la búsqueda)
		alert(word3); // null (no máscoincidencias)
		alert(regexp.lastIndex); // 0 (sereiniciaal final de la búsqueda)
		```

		Cada coincidencia es devuelta como un array con grupos y propiedades adicionales.

		Podemos conseguir todas las coincidencias en el loop:

		```js run
Expand All		@@ -65,11 +64,13 @@ while (result = regexp.exec(str)) {
		}
		```

		Tal uso de `regexp.exec` es una alternativa al método `str.match bAll`.
		Tal uso de `regexp.exec` es una alternativa al método `str.match bAll`, con más control sobre el proceso.

		A diferencia de otros métodos, podemos establecer nuestro propio `lastIndex`, para comenzar la búsqueda desde la posición dada.
		Volvamos a nuestra tarea.

		Por ejemplo, encontremos una palabra, comenzando desde la posición `4`:
		Podemos estableceer manualmente `lastIndex` a `4`, para comenzar la búsqueda desde la posición dada.

		Como aquí:

		```js run
		let str = 'let varName = "value"';
Expand All		@@ -84,8 +85,14 @@ let word = regexp.exec(str);
		alert(word); // varName
		```

		¡Problema resuelto!

		Realizamos una búsqueda de `pattern:\w+`, comenzando desde la posición `regexp.lastIndex = 4`.

		El resultado es correcto.

		...Pero espera, no tan rápido.

		Nota que la búsqueda comienza en la posición `lastIndex` y luego sigue adelante. Si no hay ninguna palabra en la posición `lastIndex` pero la hay en algún lugar posterior, entonces será encontrada:

		```js run
Expand All		@@ -94,17 +101,19 @@ let str = 'let varName = "value"';
		let regexp = /\w+/g;

		!
		// comenzando desde la posición 3
		regexp.lastIndex = 3;
		/!

		let word = regexp.exec(str);
		// encuentra coincidencia en la posición 4
		alert(word[0]); // varName
		alert(word.index); // 4
		```

		...Así que, con la propiedad `lastIndex` del indicador `pattern:g` se establecela posicióninicial de la búsqueda.
		Para algunas tareas, incluido el análisis léxico, esto está mal. Necesitamos la coincidencia enla posiciónexacta, y para ello es el flag `y`.

		El indicador `pattern:y` hace que `regexp.exec` busque exactamente en la posición `lastIndex`,ni antes ni después.
		El indicador `pattern:y` hace que `regexp.exec` busque"exactamente en" la posición `lastIndex`,no "comenzando en" ella.

		Aquí está la misma búsqueda con el indicador `pattern:y`:

Expand All		@@ -122,6 +131,8 @@ alert( regexp.exec(str) ); // varName (Una palabra en la posición 4)

		Como podemos ver, el `pattern:/\w+/y` de regexp no coincide en la posición `3` (a diferencia del indicador `pattern:g`), pero coincide en la posición `4`.

		No solamente es lo que necesitamos, el uso del indicador `pattern:y` mejora el rendimiento.

		Imagina que tenemos un texto largo, y no hay coincidencias en él. Entonces la búsqueda con el indicador `pattern:g` irá hasta el final del texto, y esto tomará significativamente más tiempo que la búsqueda con el indicador `pattern:y`.

		En tareas tales como el análisis léxico, normalmente hay muchas búsquedas en una posición exacta. Usar el indicador `pattern:y` es la clave para un buen desempeño.