fix(guide): simplify directory structure

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md

@@ -0,0 +1,9 @@
+---
+title: Check for All or None
+localeTitle: Comprobar por todos o ninguno
+---
+## Comprobar por todos o ninguno
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/extract-matches/index.md

@@ -0,0 +1,26 @@
+---
+title: Extract Matches
+localeTitle: Extraer fósforos
+---
+## Extraer fósforos
+
+Usando el método `match()` , puedes extraer partes de una cadena que coinciden con tu expresión regular. En este desafío, está extrayendo la palabra "codificación" de la cadena provista.
+
+## Sugerencia 1:
+
+Cambie su expresión regular para detectar la palabra "codificación".
+
+## Sugerencia 2:
+
+¿Llamaste al método `match()` en la cadena?
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución:
+
+```javascript
+let extractStr = "Extract the word 'coding' from this string."; 
+ let codingRegex = /coding/; 
+ let result = extractStr.match(codingRegex); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching/index.md

@@ -0,0 +1,18 @@
+---
+title: Find Characters with Lazy Matching
+localeTitle: Encuentra personajes con Lazy Matching
+---
+## Encuentra personajes con Lazy Matching
+
+#### Challange
+
+`/<.*>/` la expresión regular `/<.*>/` para devolver la etiqueta HTML `<h1>` y no el texto `<h1>Winter is coming</h1>` . Recuerda el comodín. En una expresión regular coincide con cualquier carácter.
+
+#### Solución:
+
+```js
+let text = "<h1>Winter is coming</h1>"; 
+ let myRegex = /<h1>?/; // it's the answer! 
+ let result = text.match(myRegex); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match/index.md

@@ -0,0 +1,26 @@
+---
+title: Find More Than the First Match
+localeTitle: Encuentra más que el primer partido
+---
+## Encuentra más que el primer partido
+
+Si tiene varias apariciones de su expresión regular dentro de una cadena, puede obtener la función `match()` para detectarlas todas. ¡Simplemente etiqueta a lo largo de la bandera `g` al final de tu expresión regular! Eso es lo que estás haciendo en este desafío.
+
+## Sugerencia 1:
+
+Cambie la expresión regular para que detecte la palabra "twinkle".
+
+## Sugerencia 2:
+
+Puede agregar varias etiquetas a una expresión regular! Por ejemplo, una expresión regular que detecta múltiples apariciones y las detecta independientemente del caso, puede estructurarse como `gi` o `ig` .
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución
+
+```javascript
+let twinkleStar = "Twinkle, twinkle, little star"; 
+ let starRegex = /twinkle/gi; 
+ let result = twinkleStar.match(starRegex); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt/index.md

@@ -0,0 +1,41 @@
+---
+title: Find One or More Criminals in a Hunt
+localeTitle: Encuentra uno o más criminales en una cacería
+---
+## Encuentra uno o más criminales en una cacería
+
+## El problema
+
+Un grupo de criminales escapó de la cárcel y se escapó, pero no sabes cuántos. Sin embargo, sí sabes que permanecen juntos cuando están cerca de otras personas. Eres responsable de encontrar a todos los criminales a la vez.
+
+Escriba una expresión regular codiciosa que encuentre uno o más delincuentes dentro de un grupo de otras personas. Un criminal está representado por la letra mayúscula C.
+
+### Sugerencia 1:
+
+¿Está rodeando su expresión regular en barras?
+
+```javascript
+let regexp = /t.[az]*t/; 
+```
+
+### Sugerencia 2:
+
+¿Está utilizando la marca '+' en su expresión regular?
+
+```javascript
+let regexp = /E+/; // returns E, EE, EEE patterns 
+```
+
+### Advertencia de Spoiler - Solución por delante
+
+## Solución
+
+```javascript
+let crowd = 'P1P2P3P4P5P6CCCP7P8P9'; 
+ 
+ let reCriminals = /C+/; // Change this line 
+ 
+ let matchedCriminals = crowd.match(reCriminals); 
+ console.log(matchedCriminals); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching/index.md

@@ -0,0 +1,22 @@
+---
+title: Ignore Case While Matching
+localeTitle: Ignorar caso mientras coinciden
+---
+## Ignorar caso mientras coinciden
+
+Al crear una expresión regular, es posible que desee hacer coincidir partes de la cadena que tienen la misma ortografía, pero diferentes en el caso. Para hacer esto, agregue la bandera `i` al final de la expresión regular. En este desafío, estás haciendo precisamente eso.
+
+## Sugerencia 1:
+
+Modifique la expresión regular para que detecte "freeCodeCamp", "FREECODECAMP" y "FrEeCoDeCaMp". Tal vez el uso de la bandera `i` podría ayudar?
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución
+
+```javascript
+let myString = "freeCodeCamp"; 
+ let fccRegex = /freeCodeCamp/i; 
+ let result = fccRegex.test(myString); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/index.md

@@ -0,0 +1,11 @@
+---
+title: Regular Expressions
+localeTitle: Expresiones regulares
+---
+## Expresiones regulares
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities/index.md

@@ -0,0 +1,22 @@
+---
+title: Match a Literal String with Different Possibilities
+localeTitle: Unir una cadena literal con diferentes posibilidades
+---
+## Unir una cadena literal con diferentes posibilidades
+
+Supongamos que desea hacer coincidir muchas palabras diferentes con su expresión regular; usando el `|` símbolo, que se hace posible. En este desafío, ¡estás usando ese símbolo para identificar cuatro mascotas diferentes escondidas dentro de las cuerdas!
+
+## Sugerencia 1:
+
+Dentro de la cadena literal, coloque los nombres de las mascotas, cada uno separado por el `|` símbolo.
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución:
+
+```javascriot
+let petString = "James has a pet cat."; 
+ let petRegex = /dog|cat|bird|fish/; 
+ let result = petRegex.test(petString); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md

@@ -0,0 +1,13 @@
+---
+title: Match All Letters and Numbers
+localeTitle: Unir todas las letras y números
+---
+El problema Use la clase de caracteres abreviados \\ w para contar el número de caracteres alfanuméricos en varias comillas y cadenas.
+
+Solución let quoteSample = "Los cinco magos de boxeo saltan rápidamente."; let alphabetRegexV2 = / \\ w / gi; // cambiar esta linea let result = quoteSample.match (alphabetRegexV2) .length;
+
+## Unir todas las letras y números
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers/index.md

@@ -0,0 +1,25 @@
+---
+title: Match All Non-Numbers
+localeTitle: Coincidir con todos los no números
+---
+## Coincidir con todos los no números
+
+## Sugerencia 1
+
+*   Debes intentar usar una bandera global.
+
+## Sugerencia 2
+
+*   Intente con un carácter abreviado para caracteres que no sean dígitos.
+
+# ¡¡Alerta de spoiler!! ¡Solución por delante!
+
+## Solución
+
+```javascript
+let noNumRegex = /\D/g; 
+```
+
+## Explicación
+
+*   El carácter abreviado `\D` se usa para hacer coincidir caracteres no dígitos, tiene el mismo resultado que usando `[^0-9]` ;

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers/index.md

@@ -0,0 +1,25 @@
+---
+title: Match All Numbers
+localeTitle: Coincidir todos los números
+---
+## Coincidir todos los números
+
+## Sugerencia 1
+
+*   Una bandera global te ayudará a superar este desafío.
+
+## Sugerencia 2
+
+*   Trate de usar un carácter abreviado para `d` igits.
+
+# ¡¡Alerta de spoiler!! ¡Solución por delante!
+
+## Solución
+
+```javascript
+let numRegex = /\d/g; 
+```
+
+## Explicación
+
+*   El carácter `\d` taquigrafía es un atajo para `[0-9]` , busca cualquier número entre 0 y 9.

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period/index.md

@@ -0,0 +1,25 @@
+---
+title: Match Anything with Wildcard Period
+localeTitle: Coincidir cualquier cosa con el período de comodín
+---
+## Coincidir cualquier cosa con el período de comodín
+
+## Sugerencia 1:
+
+El punto `.` Es la clave en este desafío.
+
+## Sugerencia 2:
+
+Debes poner el punto en la posición correcta.
+
+## Solución
+
+```javascript
+let exampleStr = "Let's have fun with regular expressions!"; 
+ let unRegex = /.un/; // Change this line 
+ let result = unRegex.test(exampleStr); 
+```
+
+## Explicacion
+
+El período `.` será un personaje cualquiera, por lo que las cadenas "correr", "sol", "diversión" y "juego de palabras" tienen las mismas características.

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns/index.md

@@ -0,0 +1,33 @@
+---
+title: Match Beginning String Patterns
+localeTitle: Emparejar patrones de cuerdas que comienzan
+---
+## Emparejar patrones de cuerdas que comienzan
+
+## El problema
+
+Use el carácter de intercalación en una expresión regular para encontrar "Cal" solo al principio de la cadena rickyAndCal.
+
+### Sugerencia 1:
+
+Trate de rodear su expresión regular en barras
+
+```javascript
+let testExp = /^test/; 
+ // returns true or false depending on whether test is found in the beginning of the string 
+```
+
+### Sugerencia 2:
+
+Intente usar el carácter '^' caret fuera de los corchetes como se ve en el ejemplo anterior
+
+### Alerta de Spoiler - Solución por delante
+
+## Solución
+
+```javascript
+let rickyAndCal = "Cal and Ricky both like racing."; 
+ let calRegex = /^Cal/; // Change this line 
+ let result = calRegex.test(rickyAndCal); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Characters that Occur One or More Times
+localeTitle: Relacionar los caracteres que ocurren una o más veces
+---
+## Relacionar los caracteres que ocurren una o más veces
+
+\## el problema: Desea encontrar coincidencias cuando la letra s aparece una o más veces en "Mississippi". Escribe una expresión regular que use el signo +. ## la solución
+
+let difficultSpelling = "Mississippi"; deja myRegex = / s + / g; // esta es la solución deja result = difficultSpelling.match (myRegex);

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times/index.md

@@ -0,0 +1,30 @@
+---
+title: Match Characters that Occur Zero or More Times
+localeTitle: Caracteres de coincidencia que ocurren cero o más veces
+---
+## Caracteres de coincidencia que ocurren cero o más veces
+
+Cualquier letra en una expresión regular seguida de un `*` no tiene que aparecer en la cadena probada, mientras que cualquier letra en una expresión regular seguida de un `+` debe aparecer en una cadena al menos una vez, como se muestra a continuación.
+
+```javascript
+let phrase = "ba humbug"; 
+ 
+ let regexPlus = /bah+/; 
+ let regexStar = /bah*/; 
+ 
+ regexPlus.test(phrase);  // returns false 
+ regexStar.test(phrase);  // returns true 
+```
+
+Ambos permiten cualquier número de apariciones de la misma letra en una fila, por ejemplo,
+
+```javascript
+let phrase = "wooooow look at that!"; 
+ 
+ let regexPlus = /wo+w/; 
+ let regexStar = /wo*w/; 
+ 
+ regexPlus.test(phrase); // returns true 
+ regexStar.test(phrase); // returns true 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Ending String Patterns
+localeTitle: Coincidir con patrones de cadena
+---
+## Coincidir los patrones de cadena de finalización
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Everything But Letters and Numbers
+localeTitle: Unir todo, excepto letras y números
+---
+## Unir todo, excepto letras y números
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet/index.md

@@ -0,0 +1,26 @@
+---
+title: Match Letters of the Alphabet
+localeTitle: Combina las letras del alfabeto
+---
+## Combina las letras del alfabeto
+
+En este desafío, se le pide que coincida con todas las letras del alfabeto dentro de una cadena dada. No solo estás comparando / buscando estos caracteres, sino que te piden que los extraigas.
+
+### Sugerencia 1:
+
+Recuerde que se le pide que extraiga las letras de la cadena; esto no se puede hacer con el método .test () porque devuelve Verdadero o Falso. En este caso, necesitamos extraer el resultado real de la cadena usando el método .match ().
+
+### Sugerencia 2:
+
+¿Está utilizando la marca de mayúsculas y minúsculas del método del método match () entre paréntesis? por ejemplo, regExp = / \[ae\] / vs regExp = / ae /. Lo que esto nos permite hacer es buscar en la cadena los caracteres que coincidan con \[a, b, c, ... e\] usando la notación abreviada / \[ae\] /.
+
+### Alerta de Spoiler: Solución por delante
+
+## Solución
+
+```javascript
+let quoteSample = "The quick brown fox jumps over the lazy dog."; 
+ let alphabetRegex = /[az]/ig; // Change this line 
+ let result = quoteSample.match(alphabetRegex); // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings/index.md

@@ -0,0 +1,24 @@
+---
+title: Match Literal Strings
+localeTitle: Unir cuerdas literales
+---
+## Unir cuerdas literales
+
+Este desafío no es diferente del anterior; En este caso, sin embargo, está aprendiendo que los literales de cadena distinguen entre mayúsculas y minúsculas. Eso significa que, cuando prueba si una cadena tiene un literal, buscará el caso exacto (inferior o superior) dentro de la cadena. Aprenderás cómo encontrar literales de cuerdas, independientemente de su caso, en una próxima lección.
+
+En este desafío, estás encontrando a Waldo ... ¡dentro de una cuerda!
+
+## Sugerencia 1:
+
+Cambia la línea para tener el literal de cadena correcta.
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución:
+
+```javascript
+let waldoIsHiding = "Somewhere Waldo is hiding in this text."; 
+ let waldoRegex = /Waldo/; // Change this line 
+ let result = waldoRegex.test(waldoIsHiding); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Non-Whitespace Characters
+localeTitle: Combina caracteres que no sean espacios en blanco
+---
+## Combina caracteres que no sean espacios en blanco
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet/index.md

@@ -0,0 +1,40 @@
+---
+title: Match Numbers and Letters of the Alphabet
+localeTitle: Coincidir números y letras del alfabeto
+---
+## Coincidir números y letras del alfabeto
+
+En este desafío, se le solicita que devuelva una colección de números y letras extraídas de una cadena. Nuestro objetivo es crear una expresión regular única que capture el rango de letras entre hys, y los números del 2 al 6.
+
+### Sugerencia 1:
+
+¿Estás utilizando el método match ()? Si es así, ¿estás llamando al método desde la variable apropiada? es decir
+
+```javascript
+  let input_string = "The string you are testing on" 
+  let yourRegExp = /[hs]/; 
+  let correct_result = input_string.match(yourRegExp); // passes - returns characters H to S 
+ 
+  let incorrect_result = yourRegExp.match(input_string); // fails - .match() is not a function 
+```
+
+### Sugerencia 2:
+
+¿Recordó habilitar los indicadores de expresión regular como "i" para ignorar mayúsculas y minúsculas y "g" para volver a recibir múltiples valores? Si es así, ¿estás incluyendo el caso de caracteres para los números Y las letras?
+
+```javascript
+let regexp = /[a-z1-100]/ig 
+ // above code returns all characters from A to Z, along with all numbers from 1 to 100 
+ // this includes the letter A and Z and the numbers 1 and 100 
+```
+
+### Alerta de Spoiler - Solución por delante
+
+## Solución
+
+```javascript
+let quoteSample = "Blueberry 3.141592653s are delicious."; 
+ let myRegex = /[h-s2-6]/ig; // Change this line 
+ let result = quoteSample.match(myRegex); // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities/index.md

@@ -0,0 +1,28 @@
+---
+title: Match Single Character with Multiple Possibilities
+localeTitle: Coincidir con un solo personaje con múltiples posibilidades
+---
+## Coincidir con un solo personaje con múltiples posibilidades
+
+### Extraer
+
+Usando el método match (), puedes extraer partes de una cadena que coinciden con tu expresión regular. En este desafío, estás extrayendo las vocales "a, e, i, o, u" de una cadena provista.
+
+### Sugerencia 1:
+
+¿Estás intentando usar el método test ()? Recuerde que este método solo devuelve Verdadero o Falso: necesitamos extraer las vocales de la cadena.
+
+### Sugerencia 2:
+
+¿Has intentado usar la combinación de mayúsculas y minúsculas con el carácter '\[\]' sin comas? ie \[abcd\] vs \[a, b, c, d\]
+
+### Alerta de Spoiler - ¡Solución por delante!
+
+## Solución
+
+```javascript
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it."; 
+ let vowelRegex = /[aeiou]/ig; // Change this line 
+ let result = quoteSample.match(vowelRegex); // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified/index.md

@@ -0,0 +1,40 @@
+---
+title: Match Single Characters Not Specified
+localeTitle: Coincidir con caracteres individuales no especificados
+---
+## Coincidencia de caracteres individuales no especificados
+
+En este desafío, se nos pide que devolvamos una colección de coincidencias que no están especificadas exactamente. Mientras que los desafíos de expresiones regulares anteriores te harían coincidir en el caso del personaje \[az\], este desafío nos pide que neguemos estas coincidencias utilizando el carácter de intercalación \[^ az\]. Entonces, nuestro objetivo es devolver una colección negada (no coincidentes) de letras que no son vocales ni números.
+
+## Sugerencia 1:
+
+¿Recordaste rodear tu expresión regular entre paréntesis y barras?
+
+```javascript
+let exampleRegExp = /[^az]/; 
+```
+
+Si es así, entonces vuelva a verificar que está agregando las banderas apropiadas:
+
+*   i: Ignora mayúsculas y minúsculas de búsqueda / coincidencia
+*   g: recupera valores múltiples; el valor predeterminado está configurado para devolver la primera coincidencia que encuentre
+*   ^: Niega las coincidencias siguiendo esta bandera
+
+### Sugerencia 2:
+
+Asegúrese de verificar si su rango de números es correcto: el desafío nos pide que neguemos todos los números del 0 al 99. Esto se puede hacer usando la carátula de negación colocada inmediatamente después del primer soporte de apertura de su expresión regular.
+
+```javacsript
+let numbersRegExp = /[^0-99]/ig; 
+```
+
+### Alerta de Spoiler - Solución por delante
+
+## Solución
+
+```javascript
+let quoteSample = "3 blind mice."; 
+ let myRegex = /[^aeiou^0-99]/ig; // Change this line 
+ let result = quoteSample.match(myRegex); // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md

@@ -0,0 +1,9 @@
+---
+title: Match Whitespace
+localeTitle: Emparejar espacios en blanco
+---
+## Emparejar espacios en blanco
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead/index.md

@@ -0,0 +1,19 @@
+---
+title: Positive and Negative Lookahead
+localeTitle: Lookahead positivo y negativo
+---
+## Lookahead positivo y negativo
+
+*   Recuerde usar 2 `lookaheads` para verificar los patrones en la cadena. El primer `lookahead` es muy similar al dado en el ejemplo - '(? = \\ W {3,6})' - solo el `lower-number` 3 es demasiado bajo para nuestros casos de prueba, y un `upper-number` es completamente anómalo. Este primer `lookahead` solo se usa para encontrar una cadena que consiste en una cierta cantidad de caracteres. Se debe usar un segundo `lookahead` para verificar valores numéricos consecutivos al final de la cadena.
+    
+*   El segundo `lookahead` también es similar al dado en el ejemplo - `(?=\D*\d)` - sin embargo, esta expresión también debe modificarse para pasar todos los casos de prueba. Recuerde especificar la cantidad exacta de números que desea que aparezcan al final de la cadena.
+    
+
+## Solución:
+
+```javascript
+let sampleWord = "astronaut"; 
+ let pwRegex = /(?=\w{5,})(?=\D*\d{2})/; 
+ let result = pwRegex.test(sampleWord); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end/index.md

@@ -0,0 +1,26 @@
+---
+title: Remove Whitespace from Start and End
+localeTitle: Eliminar espacios en blanco de inicio y fin
+---
+## Eliminar espacios en blanco de inicio y fin
+
+Para resolver este desafío, simplemente tiene que crear una cadena de expresiones regulares que coincida con cualquier espacio al principio o al final de la cadena.
+
+## Sugerencia 1:
+
+Piense en cómo puede seleccionar subcadenas al principio o al final de una cadena.
+
+## Sugerencia 2:
+
+Piense en cómo puede seleccionar los espacios en blanco
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución:
+
+```javascript
+let hello = "   Hello, World!  "; 
+ let wsRegex = /^\s+|\s+$/g; // Change this line 
+ let result = hello.replace(wsRegex, ''); // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames/index.md

@@ -0,0 +1,34 @@
+---
+title: Restrict Possible Usernames
+localeTitle: Restringir posibles nombres de usuario
+---
+## Restringir posibles nombres de usuario
+
+## Solución:
+
+```javascript
+let username = "JackOfAllTrades"; 
+ let userCheck = /^[az]{2,}\d*$/i; 
+ let result = userCheck.test(username); 
+```
+
+## Explique:
+
+1.  Los únicos números en el nombre de usuario deben estar al final. `\d$` Puede haber cero o más de ellos al final. `*`
+
+```javascript
+/\d*$/; 
+```
+
+2.  Las letras del nombre de usuario pueden estar en minúsculas y en mayúsculas. `i`
+
+```javascript
+/\d*$/i; 
+```
+
+3.  Los nombres de usuario deben tener al menos dos caracteres de largo. `{2,}` Un nombre de usuario de dos letras solo puede usar caracteres de letras del alfabeto. `^[az]`
+
+```javascript
+/^[az]{2,}\d*$/i; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups/index.md

@@ -0,0 +1,61 @@
+---
+title: Reuse Patterns Using Capture Groups
+localeTitle: Reutilizar patrones usando grupos de captura
+---
+## Reutilizar patrones usando el grupo de captura
+
+## Sugerencia 1:
+
+Código dado abajo:
+
+```javascript
+let testString = "test test test "; 
+ let reRegex =/(test)\s\1/; 
+ let result = reRegex.test(testString); 
+```
+
+`result` solo coincidirá con la `test test` porque `\1` en este ejemplo representa el mismo texto que el último grupo de captura `(test)` comparó más recientemente.
+
+Si tuviéramos que traducir literalmente la expresión regular, se vería algo así:
+
+```js
+let re = /(test)\s\1; 
+ let literalRe = /test\stest; 
+```
+
+Tanto `rea` como `literalRe` coincidirían con la misma cosa.
+
+## Sugerencia 2:
+
+Dado el siguiente código:
+
+```javascript
+let testString = "test test test "; 
+ let reRegex =/(test)(\s)\1\2\1/; 
+ let result = reRegex.test(testString); 
+```
+
+coincidirá con la `test test test` entera porque: `\1` repite (prueba) `\2` repeticiones (\\ s)
+
+## Sugerencia 3:
+
+El siguiente código:
+
+```javascript
+let testString = "test test test test test test"; 
+ let reRegex =/(test)(\s)\1\2\1/g; 
+ let result = reRegex.test(testString); 
+```
+
+debido a que usamos `\g` , nuestro Regex no regresa después de la primera coincidencia completa ( `test test test` ) y todas las repeticiones.
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución:
+
+```javascript
+let repeatNum = "42 42 42"; 
+ let reRegex =  /^(\d+)\s\1\s\1$/; 
+ let result = reRegex.test(repeatNum); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md

@@ -0,0 +1,9 @@
+---
+title: Specify Exact Number of Matches
+localeTitle: Especifique el número exacto de coincidencias
+---
+## Especifique el número exacto de coincidencias
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md

@@ -0,0 +1,13 @@
+---
+title: Specify Only the Lower Number of Matches
+localeTitle: Especifique solo el número inferior de coincidencias
+---
+El problema Cambie el regex haRegex para que coincida con la palabra "Hazzah" solo cuando tenga cuatro o más letras z.
+
+Solución vamos haStr = "Hazzzzah"; vamos haRegex = / Haz {4,30} ah /; // cambiar esta linea sea ​​result = haRegex.test (haStr);
+
+## Especifique solo el número inferior de coincidencias
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches/index.md

@@ -0,0 +1,33 @@
+---
+title: Specify Upper and Lower Number of Matches
+localeTitle: Especifique el número superior e inferior de coincidencias
+---
+## Especifique el número superior e inferior de coincidencias
+
+Recuerde que `/a{2,4}/` devolverá `true` siempre que haya entre dos y cuatro a juntas. Devolverá `true` para cualquier cadena que tenga más de cuatro a juntas también.
+
+Todas estas cadenas devolverán `true` :
+
+```javascript
+let threeAs = "aaa"; 
+ let fourAs = "aaaa"; 
+ let sevenAs = "aaaaaaa"; 
+ 
+ let myRegex = /a{2,4}/; 
+ myRegex.test(threeAs) ; // true 
+ myRegex.test(fourAs) ; // true 
+ myRegex.test(sevenAs) ; // true 
+```
+
+## ¡Alerta Spolier!
+
+Recuerde usar `\s` después de `Oh{3,6}` para incluir un espacio en blanco, seguido de `no` para pasar todos los casos de prueba. Todos los casos de prueba se escriben con una O mayúscula, sin embargo, los casos de prueba también se pueden pasar usando `ignore-case` : `/oh{3,6}\sno/i`
+
+## Solución:
+
+```javascript
+let ohStr = "Ohhh no"; 
+ let ohRegex = /Oh{3,6}\sno/; // Change this line 
+ let result = ohRegex.test(ohStr); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace/index.md

@@ -0,0 +1,23 @@
+---
+title: Use Capture Groups to Search and Replace
+localeTitle: Utilice los grupos de captura para buscar y reemplazar
+---
+## Utilice los grupos de captura para buscar y reemplazar
+
+El uso de `.replace()` con el primer parámetro establecido para encontrar la parte de la cadena original a reemplazar, y el segundo parámetro debe ser el reemplazo.
+
+## Sugerencia 1:
+
+Modifique la expresión regular para que `fixRegex` detecte la parte de la cadena a reemplazar y la variable `replaceText` debe modificar a la cadena que reemplazará a `fixRegex` .
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución
+
+```javascript
+let huhText = "This sandwich is good."; 
+ let fixRegex = /good/; // Change this line 
+ let replaceText = "okey-dokey"; // Change this line 
+ let result = huhText.replace(fixRegex, replaceText); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method/index.md

@@ -0,0 +1,22 @@
+---
+title: Using the Test Method
+localeTitle: Usando el Método de Prueba
+---
+## Usando el Método de Prueba
+
+En este desafío, se está comprobando para ver si una cadena contiene una cierta "expresión regular" o **expresiones regulares** **(reg** ular **ex** pressions). Usarás el método `test()` para hacer eso.
+
+## Sugerencia 1:
+
+Llame al método de prueba en `myRegex` . ¿Cuál crees que será el argumento?
+
+## Alerta de Spoiler - ¡Solución por delante!
+
+## Solución
+
+```javascript
+let myString = "Hello, World!"; 
+ let myRegex = /Hello/; 
+ let result = myRegex.test(myString); // Change this line 
+
+```