Las expresiones regulares son cadenas especiales que representan un patrón de búsqueda. También conocidos como "regex" o "regexp", ayudan a los programadores a unir, buscar y reemplazar texto. Las expresiones regulares pueden parecer cítricas porque algunos caracteres tienen un significado especial. El objetivo es combinar los símbolos y el texto en un patrón que coincida con lo que desea, pero solo con lo que desea. Esta sección cubrirá los caracteres, algunos atajos y los usos comunes para escribir expresiones regulares.

Upcoming Lessons

• Using the Test Method
• Match Literal Strings
• Match a Literal String with Different Possibilities
• Ignore Case While Matching
• Extract Matches
• Find More Than the First Match
• Match Anything with Wildcard Period
• Match Single Character with Multiple Possibilities
• Match Letters of the Alphabet
• Match Numbers and Letters of the Alphabet
• Match Single Characters Not Specified
• Match Characters that Occur One or More Times
• Match Characters that Occur Zero or More Times
• Find Characters with Lazy Matching
• Find One or More Criminals in a Hunt
• Match Beginning String Patterns
• Match Ending String Patterns
• Match All Letters and Numbers
• Match Everything But Letters and Numbers
• Match All Numbers
• Match All Non-Numbers
• Restrict Possible Usernames
• Match Whitespace
• Match Non-Whitespace Characters
• Specify Upper and Lower Number of Matches
• Specify Only the Lower Number of Matches
• Specify Exact Number of Matches
• Check for All or None
• Positive and Negative Lookahead
• Check For Mixed Grouping of Characters
• Reuse Patterns Using Capture Groups
• Use Capture Groups to Search and Replace
• Remove Whitespace from Start and End

Las expresiones regulares se utilizan en lenguajes de programación para unir partes de cadenas. Crear patrones para ayudarte a hacer esa coincidencia.

Si desea encontrar la palabra "the" en la cadena "The dog chased the cat" , puede usar la siguiente expresión regular: /the/. Tengan en cuenta que las comillas no son necesarias dentro de la expresión regular.

JavaScript tiene múltiples formas de usar expresiones regulares. Una forma de probar una expresión regular es usando el método .test(). El mètodo .test() toma la exprsioón regular, la aplica a una cadena (que se coloca entre paréntesis) y devuelve true o false si su patrón encuentra algo o no.

let testStr = "freeCodeCamp";
let testRegex = /Code/;
testRegex.test(testStr);
// Returns true

Aplique la expresión regular myRegex en la cadena myString usando el método .test().

El código con la solución se encuentra aquí:Download

En el último desafío, buscó la palabra "Hello" usando la expresión regular /Hello/. Esa expresión regular buscó una coincidencia literal de la cadena "Hello". Aquí hay otro ejemplo buscando una coincidencia literal de la cadena "Kevin":

let testStr = "Hello, my name is Kevin.";
let testRegex = /Kevin/;
testRegex.test(testStr);
// Returns true

Cualquier otra forma de "Kevin" no coincidirá. Por ejemplo, la expresión regular /Kevin/ no coincidirá con "kevin" o "KEVIN".

let wrongRegex = /kevin/;
wrongRegex.test(testStr);
// Returns false

Un desafío futuro mostrara cómo combinar esas otras formas también.

Complete la expresión regular waldoRegex para encontrar "Waldo" en la cadena waldoIsHiding con una coincidencia literal.

El código con la solución se encuentra aquí:Download

Usando expresiones regulares como /coding/ , puede buscar el patrón "coding" en otra cadena.

Esto es poderoso para buscar cadenas individuales, pero está limitado a un solo patrón. Puede buscar múltiples patrones utilizando la alternancia el operador OR.

Este operador hace coincidir los patrones antes o después. Por ejemplo, si deseas hacer coincidir "yes" o "no", la expresión regular que desea es /yes|no/.

También puede buscar más que solo dos patrones. Puede hacer esto agregando más patrones con más operadores OR separándolos, como /yes|no|maybe/.

Complete la expresión regular petRegex para que coincida con las mascotas "dog", "cat", "bird" o "fish".

El código con la solución se encuentra aquí:Download

Hasta ahora, has visto expresiones regulares para hacer coincidencia literales de cadenas. Pero a veces, es posible que también desee hacer coincidencias las diferencias entre mayúsculas y minúsculas.

Puede hacer coincidir ambos casos usando lo que se llama una bandera. Hay otras banderas, pero aquí se centrará en la bandera que ignora las mayúsculas y minúsculas: la bandera i. Puede usarlo agregándolo a la expresión regular. Un ejemplo de uso de este indicador es /ignorecase/i. Esta expresión regular puede coincidir con las cadenas "ignorecase", "igNoreCase" e "IgnoreCase".

Escriba una expresión regular fccRegex para que coincida con "freeCodeCamp", sin importar su case. Su expresión regular no debe coincidir con ninguna abreviatura o variación con espacios.

El código con la solución se encuentra aquí:Download

Hasta ahora, solo ha estado comprobando si existe un patrón o no dentro de una cadena. También puede extraer las coincidencias reales que encontró con el método .match().

Para usar el método .match(), aplique el método en una cadena y pase la expresión regular dentro de los paréntesis. Aquí hay un ejemplo:

"Hello, World!".match(/Hello/);
// Returns ["Hello"]
let ourStr = "Regular expressions";
let ourRegex = /expressions/;
ourStr.match(ourRegex);
// Returns ["expressions"]

Aplique el método .match() para extraer la palabra coding.

El código con la solución se encuentra aquí:Download

Hasta ahora, solo ha podido extraer o buscar un patrón una vez.

let testStr = "Repeat, Repeat, Repeat";
let ourRegex = /Repeat/;
testStr.match(ourRegex);
// Returns ["Repeat"]

Para buscar o extraer un patrón más de una vez, puede usar la bandera g.

let repeatRegex = /Repeat/g;
testStr.match(repeatRegex);
// Returns ["Repeat", "Repeat", "Repeat"]

Usando la expresión regular startRegex, encuentre y extraiga ambas palabras "Twinkle" de la cadena twinkleStar.

Nota: Puede tener varias banderas en su expresión regular como /search/gi.

El código con la solución se encuentra aquí:Download

A veces no (o no necesita) conocer los caracteres exactos en sus patrones. Pensando en todas las palabras que coinciden, digamos, un error ortográfico llevaría mucho tiempo. Afortunadamente, puede ahorrar tiempo usando el carácter comodín: ..

El carácter comodín, coincidirá con cualquier personaje. El comodín también se llama dot y period. Puede usar el carácter comodín como cualquier otro personaje en la expresión regular. Por ejemplo, si desea hacer coincidir "hug", "hug", "hut" y "hut", puede usar la expresión regular /hu./ para unir las cuatro palabras.

let humStr = "I'll hum a song";
let hugStr = "Bear hug";
let huRegex = /hu./;
huRegex.test(humStr); // Returns true
huRegex.test(hugStr); // Returns true

Complete el unRegex para que coincida con las cadenas "run", "sun", "fun", "pun", "num" y "bun". Su expresión regular deber usar el carácter comodín.

El código con la solución se encuentra aquí:Download

Aprendió a unir patrones literales (/literal/) y caracteres comodín (/./). Esos son los extremos de la expresiones regulares, donde uno encuentra coincidencias exactas y el otro coincide con todo.Hay opciones que son un equilibrio entre los dos extremos.

Puede buscar un patrón literal con cierta flexibilidad con las clases de caracteres. Las clases de caracteres le permiten definir un grupo de caracteres que desea unir colocándolos dentro de corchetes cuadrados ([ y ]).

Por ejemplo, desea hacer coincidir "bag", "big", y "bug", pero no "bog". Puede crear la expresión regular /b[aiu]g/ para hacer esto. El [aiu] es la clase de caracteres que solo coincidirá con los caracteres "a", "i" o "u".

let bigStr = "big";
let bagStr = "bag";
let bugStr = "bug";
let bogStr = "bog";
let bgRegex = /b[aiu]g/;
bigStr.match(bgRegex); // Returns ["big"]
bagStr.match(bgRegex); // Returns ["bag"]
bugStr.match(bgRegex); // Returns ["bug"]
bogStr.match(bgRegex); // Returns null

Use una clase de caracteres con vocales (a, e, i, o, u) en su expresión regular vowelRegex para encontrar todas las vocales en la cadena quoteSample.

Nota. Asegúrese de hacer coincidir las vocales mayúsculas u minúsculas.

El código con la solución se encuentra aquí:Download

Viste cómo puedes usar conjuntos de caracteres para especificar un grupo de caracteres para que coincidan , pero eso es mucho escribir cuando necesitas unir una gran variedad de caracteres (por ejemplo, cada letra del alfabeto). Afortunadamente, hay una característica incorporada que hace que esto sea breve y simple.

Dentro de un conjunto de caracteres, puede definir un rango de caracteres para que coincida con un guión: -.

Por ejemplo, para hacer coincidir las letras minúsculas de la a a la e, usaría [a-e].

let catStr = "cat";
let batStr = "bat";
let matStr = "mat";
let bgRegex = /[a-e]at/;
catStr.match(bgRegex); // Returns ["cat"]
batStr.match(bgRegex); // Returns ["bat"]
matStr.match(bgRegex); // Returns null

Haga coincidir todas las letras en la cadena quoteSample.

Nota: Asegúrese de hacer coincidir las letras mayúsculas y minúsculas.

El código con la solución se encuentra aquí:Download

El uso del guión - para hacer coincidir un rango de caracteres no se limita a las letras. También funciona para hacer coincidir un rango de números.

Por ejemplo, /[0-5]/ coincide con cualquier número entre 0 y 5 , incluidos los 0 y 5.

Además, es posible combinar un rango de letras y números en un solo conjunto de caracteres.

let jennyStr = "Jenny8675309";
let myRegex = /[a-z0-9]/ig;
// matches all letters and numbers in jennyStr
jennyStr.match(myRegex);

Cree una expresión regular única que coincida con un rango de letras entre h y s, y un rango de números entre 2 y 6. Recuerde incluir las banderas apropiadas en la expresión regular.

El código con la solución se encuentra aquí:Download

Hasta ahora, ha creado un conjunto de caracteres que desea unir, pero también puede crear un conjunto de caracteres que no desea unir. Estos tipos de conjuntos de caracteres se denominan conjuntos de caracteres negados.

Para crear un conjunto de caracteres negados, coloque un carácter de intercalación (^) después del corchete que no desea hacer coincidir.

Por ejemplo, / [^ aeiou] /gi coincide con todos los caracteres que no son vocales. Tenga en cuenta que los caracteres como .,!,[,],@, / y el espacio en blanco coinciden el conjunto de caracteres de vocales negados solo excluye los caracteres de vocales.

Cree una expresión regular única que coincida con todos los caracteres que no son un número o una vocal. Recuerde incluir las banderas apropiadas en la expresión regular.

El código con la solución se encuentra aquí:Download

A veces, debe hacer coincidir un carácter (o grupo de caracteres) que aparece una o más veces seguidas. Esto significa que ocurre al menos una vez y puede repetirse.

Puede usar el carácter + para verificar si ese es el caso. Recuerde, el personaje o patrón tiene que estar presente consecutivamente. Es decir, el personaje tiene que repetir uno tras otro.

Por ejemplo, /a+/g encontraría una coincidencia en "abc" y devolvería ["a"]. Debido al +, también encontraría una sola coincidencia en "aabc" y devolvería ["aa"].

Si, en cambio, estuviera comprobando la cadena "abab", encontraría dos coincidencias porque los caracteres a no están en un fila,hay una b entre ellos. Finalmente, dado que no hay "a" en la cadena "bcd", no encontraría una coincidencia.

Debería buscar coincidencias cuando la letra s aparece una o más veces en "Mississippi". Escriba una expresión regular que use el signo +.

El código con la solución se encuentra aquí:Download

El último desafío el signo más +,para buscar los caracteres que aparecen una o más veces. También hay una opción que coincide con los caracteres que ocurren cero o más veces.

El personaje para hacer esto es el asterisco o estrella : *

let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
let goRegex = /go*/;
soccerWord.match(goRegex); // Returns ["goooooooo"]
gPhrase.match(goRegex); // Returns ["g"]
oPhrase.match(goRegex); // Returns null

Para este desafío, chewieQuote se ha inicializado como "¡Aaaaaaaaaaaaaaaarrrgh!" detrás de escena. Cree una expresión regular chewieRegex que use el carácter * para que coincida con un carácter "A" en mayúscula seguido inmediatamente por cero o más caracteres "a" en minúscula en chewieQuote . Su expresión regular no necesita banderas ni clases de caracteres, y no debe coincidir con ninguna de las otras citas.

El código con la solución se encuentra aquí:Download

En expresiones regulares, una coincidencia codiciosa encuentra la parte más larga posible de una cadena que se ajusta el patrón de expresiones regulares y la devuelva como una coincidencia. La alternativa se llama una coincidencia diferida, que encuentra la parte más pequeña posible de la cadena que satisface el patrón de expresiones regulares.

Puede aplicar la expresión regular /t[a-z]*i/ a la cadena "titanic" . Esta expresión regular es básicamente un patrón que comienza con t, termina con i y tiene algunas letras en el medio.

Las expresiones regulares son codiciosas por defecto, por lo que la coincidencia devolvería ["titani"]. Encuentra la subcadena más grande posible para ajustarse al patrón.

Sin embargo, puedes usar el ? personaje para cambiarlo a coincidencia perezosa. "titanic" comparado con la expresión regular ajustada de /t[a-z]*?i/ devuelve ["ti"].

Nota. Se debe evitar analizar HTML con expresiones regulares, pero el patrón que coincide con una cadena HTML con expresiones regulares está completamente bien.

Arregle la expresión regular /<.*>/ para que devolver la etiqueta HTML <h1> y no el texto "<h1> Se acerca el invierno </h1>". Recuerda el comodín . en una expresión regular coincide con cualquier caracter.

El código con la solución se encuentra aquí:Download

Es hora de hacer una pausa y probar tus nuevas habilidades de escritura de expresiones regulares. Un grupo de delincuentes escapó de la cárcel y huyó, pero no sabes cuántos. Sin embargo, usted sabe que permanecen juntos cuando están cerca de otras personas. Usted es responsable de encontrar a todos los criminales a la vez.

Aquí hay un ejemplo para revisar cómo hacer esto:

La expresión regular /z+/ coincide con la letra z cuando aparece una o más veces seguidas. Encontraría coincidencias en todas las siguientes cadenas:

"z"
"zzzzzz"
"ABCzzzz"
"zzzzABC"
"abczzzzzzzzzzzzzzzzzzzzzabc"

Pero no encuentra coincidencias en las siguientes cadenas ya que no hay caracteres de z:

""
"ABC"
"abcabc"

Escribe una expresión regular codiciosa que encuentre uno o más delincuentes dentro de un grupo de personas. Un criminal está representado por la letra mayúscula C.

El código con la solución se encuentra aquí:Download

Los desafíos anteriores mostraron que las expresiones regulares se pueden usar para buscar varias coincidencias. También se utilizan para buscar patrones en posiciones específicas en cadenas.

En un desafío anterior, usó el carácter de intercalación ^ dentro de un conjunto de caracteres para crear un conjunto de caracteres negando de la forma [^ thingsThatWillNotBeMatched]. Fuera de un conjunto de caracteres, el cursor se usa para buscar patrones al comienzo de las cadenas.

let firstString = "Ricky is first and can be found.";
let firstRegex = /^Ricky/;
firstRegex.test(firstString);
// Returns true
let notFirst = "You can't find Ricky now.";
firstRegex.test(notFirst);
// Returns false

Use el carácter de intercalación en una expresión regular para encontrar "Cal" solo al comienzo de la cadena rickAndCal.

El código con la solución se encuentra aquí:Download

En el último desafío, aprendiste a usar el carácter de intercalación para buscar patrones al comienzo de las cadenas. También hay una forma de buscar patrones al final de las cadenas.

Puede buscar el final de las cadenas con el signo $ al final de la expresión regular.

let theEnding = "This is a never ending story";
let storyRegex = /story$/;
storyRegex.test(theEnding);
// Returns true
let noEnding = "Sometimes a story will have to end";
storyRegex.test(noEnding);
// Returns false

Use el carácter de anclaje $ para hacer coincidir la cadena "caboose"al final de la cadena caboose.

El código con la solución se encuentra aquí:Download

Usando clases de caracteres, pudo buscar todas las letras del alfabeto con [a-z]. Este tipo de clase de caracteres es lo suficientemente común como para que tenga un acceso directo, aunque también incluye algunos caracteres adicionales.

La clase de caracteres más cercana en JavaScript que coincide con el alfabeto es \w. Este acceso directo es igual a [A-Za-z0-9_]. Esta clase de caracteres coincide con letras mayúsculas y minúsculas más números. Tenga en cuenta que estra clase de caracteres también incluye el carácter de subrayado (_).

let longHand = /[A-Za-z0-9_]+/;
let shortHand = /\w+/;
let numbers = "42";
let varNames = "important_var";
longHand.test(numbers); // Returns true
shortHand.test(numbers); // Returns true
longHand.test(varNames); // Returns true
shortHand.test(varNames); // Returns true

Estas clases de caracteres de acceso directo también se conocen como clases de caracteres abreviados.

Estas clases de caracteres de acceso directo también se conocen como clases de caracteres abreviados.

Use la clase de caracteres abreviados \w para contar el número de caracteres alfanuméricos en varias comillas y cadenas.

El código con la solución se encuentra aquí:Download

Aprendiste que puedes usar un atajo para unir alfanuméricos [A-Za-z0-9_] usando \w. Un patrón natural que quizás desee buscar es lo contrario de los alfanuméricos.

Puede buscar el opuesto de \w con \W. Tenga en cuenta que el patrón opuesto usa una letra mayúscula. Este acceso directo es el mismo que [^ A-Za-z0-9_].

let shortHand = /\W/;
let numbers = "42%";
let sentence = "Coding!";
numbers.match(shortHand); // Returns ["%"]
sentence.match(shortHand); // Returns ["!"]

Utilice la clase de caracteres abreviados \W para contar el número de caracteres no alfanuméricos en varias comillas y cadenas.

El código con la solución se encuentra aquí:Download

Has aprendido atajos para patrones de cadena comunes como los alfanuméricos. Otro patrón común es buscar solo dígitos o números.

El acceso directo para buscar caracteres de dígitos es \d, con un minúscula d. Esto es igual a la clase de caracteres [0-9], que busca un solo carácter de cualquier número entre cero y nueve.

Use la clase de caracteres abreviados \d para contar cuántos dígitos hay en los títulos de las películas. Los números escritos ("six" en lugar de 6) no cuentan.

El código con la solución se encuentra aquí:Dowload

El último desafío mostró cómo buscar dígitos usando el acceso director \d con una d minúscula. También puede buscar no dígitos utilizando un acceso directo similar que utiliza una D mayúscula en su lugar.

El atajo para buscar caracteres que no sean dígitos es \D. Esto es igual a la clase de caracteres ``[^0-9], que busca un solo carácter que no sea un número entre cero y nueve.

Use la clase de caracteres abreviados para no dígitos \D para contar cuántos no dígitos hay en los títulos de las películas.

El código con la solución se encuentra aquí:Download

Los nombres de usuario se usan en todas partes en internet. Son los que dan a los usuarios una identidad única en sus sitios favoritos.

Debe verificar todos los nombres de usuario en una base de datos. Aquí hay algunas reglas simples que los usuarios deben seguir al crear su nombre de usuario.

1. Los nombres de usuario solo pueden usar caracteres alfanuméricos.
2. Los únicos números en el nombre de usuario deben estar al final.Puede haber cero o más de ellos al final.
3. Las letras de los nombres de usuario pueden ser minúsculas y mayúsculas.
4. Los nombres de usuario deben tener al menos dos caracteres de longitud. Un nombre de usuario de dos caracteres solo puede usar letras del alfabeto como caracteres.

Cambie la expresión regular userCheck para que se ajuste a las restricciones enumeradas anteriormente.

let username = "JackOfAllTrades";
let userCheck = /^[a-z]([0-9][0-9]+|[a-z]+\d*)$/i;; // Change this line
let result = userCheck.test(username);

^ - start of input

[a-z] - first character is a letter

[0-9][0-9]+ - ends with two or more numbers

| - or

[a-z]+ - has one or more letters next

\d* - and ends with zero or more numbers

$ - end of input

i - ignore case of input

El código con la solución se encuentra aquí:Download

Los desafíos han cubierto las letras coincidentes del alfabeto y los números. También puede hacer coincidir el espacio en blanco o los espacios entre letras.

Puede buscar espacios en blanco usando \s, que es una s minúscula. Este patrón no solo coincide con espacios en blanco, sino también con retorno de carro, tabulación, avance de formulario y nuevos caracteres de línea. Puede pensar que similar a la clase de caracteres [ \r\t\f\n\v]

let whiteSpace = "Whitespace. Whitespace everywhere!"
let spaceRegex = /\s/g;
whiteSpace.match(spaceRegex);
// Returns [" ", " "]

Cambie la expresión regular countWhiteSpace para buscar varios caracteres de espacio en blanco en una cadena.

El código con la solución se encuentra aquí:Download

Aprendiste a buscar espacios en blanco usando \s, con una s minúscula. También puede buscar todo excepto espacios en blanco.

Busque espacios que no sean espacios en blanco usando \S que es un s mayúscula. Este patrón no coincidirá con espacios en blanco, retorno de carro, tabulación, avance de formulario y nuevos caracteres de línea. Puede pensar que es similar a la clase de caracteres [^ \r\t\f\n\v].

let whiteSpace = "Whitespace. Whitespace everywhere!"
let nonSpaceRegex = /\S/g;
whiteSpace.match(nonSpaceRegex).length; // Returns 32

Cambie el recuento de countNonWhiteSpace para buscar caracteres que no sean espacios en blanco en una cadena.

El código con la solución se encuentra aquí:Download

Recuerde que utiliza el signo más + para buscar uno o más caracteres y el asterisco * para buscar cero o más caracteres. Estos son convenientes, pero a veces desea hacer coincidir un cierto rango de patrones.

Puedes especificar el número inferior y superior de patrones con especificadores de cantidad. Los especificadores de cantidad se usan con llaves ({ y }). Pones dos números entre llaves - para el número inferior y superior de patrones.

Por ejemplo, para hacer coincidir solo la letra a que aparece entre 3 y 5 veces en la cadena "ah", su expresión regular sería / a {3,5} h /.

let A4 = "aaaah";
let A2 = "aah";
let multipleA = /a{3,5}h/;
multipleA.test(A4); // Returns true
multipleA.test(A2); // Returns false

Cambie la expresión regular ohRegex para que coincida con la frase completa "Oh no" solo cuando tenga de 3 a 6 letras h.

El código con la solución se encuentra aquí:Download

Puede especificar el número inferior y superior de patrones con especificadores de cantidad utilizando llaves. A veces solo desea especificar el número inferior de patrones sin límite superior.

Para especificar solo el número más bajo de patrones, mantenga el primer número seguido de una coma.

Por ejemplo, para hacer coincidir solo la cadena "hah" con la letra a que aparece al menos 3 veces, su expresión regular sería / ha {3,} h /.

let A4 = "haaaah";
let A2 = "haah";
let A100 = "h" + "a".repeat(100) + "h";
let multipleA = /ha{3,}h/;
multipleA.test(A4); // Returns true
multipleA.test(A2); // Returns false
multipleA.test(A100); // Returns true

Cambie la expresión regular haRegex para que coincida con la palabra "Hazzah" solo cuando tenga cuatro o más letras z.

El código con la solución se encuentra aquí:Download

Puede especificar el número inferior y superior de patrones con especificadores de cantidad utilizando llaves. A veces solo quieres un número especifico de coincidencias.

Para especificar un cierto número de patrones, solo tiene ese número entre los corchetes.

Por ejemplo, para coincidir solo la palabra "hah" con la letra a 3 veces, su expresión regular sería / ha {3} h /.

let A4 = "haaaah";
let A3 = "haaah";
let A100 = "h" + "a".repeat(100) + "h";
let multipleHA = /ha{3}h/;
multipleHA.test(A4); // Returns false
multipleHA.test(A3); // Returns true
multipleHA.test(A100); // Returns false

Cambie la expresión regular timRegex para que coincida con la palabra "Timber" solo cuando tenga cuatro letras m.

El código con la solución se encuentra aquí:Download

A veces, los patrones que desea buscar puede tener partes que pueden existir o no. Sin embargo, puede ser importante verificarlos de todos modos.

Puedes especificar la posible existencia de un elemento con un signo de interrogación, ? esto comprueba cero o uno del elemento anterior. Puede pensar en este símbolo como diciendo que el elemento anterior es opcional.

Por ejemplo, existen ligeras diferencias en el inglés americano y británico y puede usar el signo de interrogación para que coincida con ambas formas de escribir.

let american = "color";
let british = "colour";
let rainbowRegex= /colou?r/;
rainbowRegex.test(american); // Returns true
rainbowRegex.test(british); // Returns true

Cambie la expresión regular favRegex para que coincida con la versión de la palabra en inglés americano (favorite) y en ingles británico (favourite).

El código con la solución se encuentra aquí:Download

Los lookaheads son patrones que le dicen a JavaScript que mire hacia adelante en su cadena para buscar patrones más adelante. Esto puede ser útil cuando desea buscar múltiples patrones en la misma cadena.

Hay dos tipos de lookaheads: positivo y negativo.

Una anticipación positiva buscará asegurarse de que el elemento en el patrón de búsqueda esté allí, pero en realidad no coincidirá. Se usa una búsqueda anticipada positiva como (? = ...) donde ... es la parte requerida que no coincide.

Por otro lado, una búsqueda anticipada negativa buscará asegurarse de que el elemento en el patrón de búsqueda no esté allí. Se usa un lookahead negativo como (?! ...) ```donde el ...`` es el patrón en el que no desea estar allí.

Los lookheads son un poco confusos, pero algunos ejemplos ayudarán.

let quit = "qu";
let noquit = "qt";
let quRegex= /q(?=u)/;
let qRegex = /q(?!u)/;
quit.match(quRegex); // Returns ["q"]
noquit.match(qRegex); // Returns ["q"]

Un uso más práctico de lookheads es verificar dos o más patrones en una cadena. Aquí hay un verificador de contraseña (ingenuamente) que busca entre 3 y 6 caracteres y al menos un número:

let password = "abc123";
let checkPass = /(?=\w{3,6})(?=\D*\d)/;
checkPass.test(password); // Returns true

Use lookheads en pwRegex para hacer coincidir las contraseñas que tengan más de 5 caracteres, no comiencen con números y tengan dos dígitos consecutivos.

El código con la solución se encuentra aquí:Download

Algunas veces queremos verificar grupos de caracteres usando una Expresión Regular y para lograr eso usamos paréntesis ().

Si desea encontrar Penguin or Pumpkin en una cadena, puede usar la siguiente expresión regular; /P(engu|umpk)in/g

Luego verifique si los grupos de cadenas deseados están en la cadena de prueba utilizando el método test().

let testStr = "Pumpkin";
let testRegex = /P(engu|umpk)in/;
testRegex.test(testStr);
// Returns true

Arregle la expresión regular para que compruebe los nombres de Franklin Roosevelt o Eleanor Roosevelt de manera sensible a mayúsculas y minúsculas y debería hacer concesiones para los segundos nombres.

Luego arregle el código para que la expresión regular que ha creado se verifique contra myString y se devuelve verdadero o falso dependiendo de si la expresión regular coincide.

El código con la solución se encuentra aquí:Download

Algunos patrones que busca se producirán varias veces en una cadena. Es un desperdicio repetir manualmente esa expresión regular. Hay una mejor manera de especificar cuándo tiene varias subcadenas repetidas en su cadena.

Puede buscar subcadenas repetidas utilizando grupos de captura. Los paréntesis, (y), se utilizan para buscar subcadenas repetidas. Pones la expresión regular del patrón que se repetirá entre paréntesis.

Para especificar dónde aparecerá esa cadena de repetición, utilice una barra diagonal inversa (\) y luego un número. Este número comienza en 1 y aumenta con cada grupo de captura adicional que use. Un ejemplo sería \1 para que coincida con el primer grupo.

El siguiente ejemplo coincide con cualquier palabra que aparece dos veces separada por un espacio:

let repeatStr = "regex regex";
let repeatRegex = /(\w+)\s\1/;
repeatRegex.test(repeatStr); // Returns true
repeatStr.match(repeatRegex); // Returns ["regex regex", "regex"]

El uso de método .match() en una cadena devolverá una matriz con la cadena que coincide, junto con su grupo de captura.

Utilice los grupos de captura de reRegex para hacer coincidir los números que se repiten solo tres veces en una cadena, cada uno separado por un espacio.

El código con la solución se encuentra aquí:Download

La búsqueda es útil. Sin embargo, puede hacer que la búsqueda sea aún más poderosa cuando también cambia (o reemplaza) el texto que coincide.

Puede buscar y reemplazar texto en una cadena usando .replace() en una cadena. Las entradas para .replace() es primero el patrón de expresiones regulares que desea buscar. El segundo parámetro es la cadena para reemplazar la coincidencia o una función para hacer algo.

let wrongText = "The sky is silver.";
let silverRegex = /silver/;
wrongText.replace(silverRegex, "blue");
// Returns "The sky is blue."

También puede acceder a los grupos de captura en la cadena de reemplazo con signos de ($).

"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
// Returns "Camp Code"

Escriba una fixRegex de expresiones regulares utilizando tres grupos de captura que buscarán cada palabra en la cadena "one two three". Luego actualice la variable replaceText para reemplacar "one two three" por la cadena " three two one" y asigne el resultado a la variable resultado. Asegúrese de utilizar grupos de captura en la cadena de reemplazo utilizando la sintaxis de singno dólar ($).

El código con la solución se encuentra aquí:Download

A veces, los caracteres de espacio en blanco alrededor de las cadenas no son deseados pero están ahí. El procesamiento típico de las cadenas es eliminar el espacio en blanco al principio y al final.

Escriba una expresión regular y use los métodos de cadena apropiados para eliminar espacio en blanco al principio y al final de las cadenas.

Nota: El método String.prototype.trim () funcionaría aquí, pero deberá completar este desafío utilizando expresiones regulares.

El código con la solución se encuentra aquí:Download