EXPRESIONES REGULARES

CARBAJAL LALUPU MARCO

NIQUEN ALVARADO JOSE
EXPLIQUE EL FUNDAMENTO MATEMATICO DE LAS EXPRESIONES
REGULARES. REGLAS BASICAS Y EJEMPLOS DE SU FUNCIONAMIENTO.
Las expresiones regulares son patrones utilizados para encontrar una
determinada combinación de caracteres dentro de una cadena de texto. En
lenguajes formales, las expresiones regulares también son objetos. Estos
patrones son utilizados a través de los métodos exec y test de RegExp, así
como los métodos match, replace, search y split de String.
Específicamente, las expresiones regulares se construyen utilizando los
operadores unión, concatenación y clausura de Kleene. Toda expresión
regular tiene algún autómata finito asociado.
Alternación
Una barra vertical separa las alternativas. Por ejemplo, "marrón|castaño" se
corresponde con marrón o castaño.
Cuantificación
Un cuantificador tras un carácter específica la frecuencia con la que éste puede
ocurrir. Los cuantificadores más comunes son "?", "+" y "*":
?
El signo de interrogación indica que el carácter que le precede puede aparecer
como mucho una vez. Por ejemplo, "ob?scuro" se corresponde
con oscuro y obscuro.
+
El signo más indica que el carácter que le precede debe aparecer al menos una
vez. Por ejemplo, "ho+la" describe el conjunto
infinito hola, hoola, hooola, hoooola, etc.
*
El asterisco indica que el carácter que le precede puede aparecer cero, una, o
más veces. Por ejemplo, "0*42" se corresponde con 42, 042, 0042, 00042, etc.
Agrupación
Los paréntesis pueden usarse para definir el ámbito y precedencia de los demás
operadores. Por ejemplo, "(p|m)adre" es lo mismo que "padre|madre", y
"(des)?amor" se corresponde con amor y con desamor.

Los constructores pueden combinarse libremente dentro de la misma expresión,

por lo que "H(ae?|ä)ndel" equivale a "H(a|ae|ä)ndel".
La sintaxis precisa de las expresiones regulares cambia según las herramientas
y aplicaciones consideradas.
Creación de una expresión regular
Una expresión regular puede crearse de cualquiera de las siguientes dos
maneras:
 Utilizando una representación literal de la expresión regular, la cual
consiste en un patrón encerrado entre diagonales, como a continuación:
var re = /ab+c/;
La representación literal ofrece la compilación de la expresión regular cuando el
script esté cargado. Cuando la expresión regular permanecerá constante, utilice
esta declaración para un mejor desempeño.

 Llamando a la función constructora del objeto RegExp, como a

continuación:
var re = new RegExp ( "ab + c");

El uso de la función constructora ofrece la compilación en tiempo de ejecución

de la expresión regular. Utilice la función constructora cuando sepa que el patrón
de la expresión regular estará cambiando, o cuando desconozca el patrón y deba
obtenerlo de otra fuente, como por ejemplo del usuario.

Escribiendo un patrón de expresión regular

Un patrón de expresión regular se compone de caracteres simples, como /abc/,
o una combinación de caracteres simples y especiales, como /ab*c/ o /Chapter
(\d+)\.\d*/. El segundo ejemplo incluye paréntesis, los cuales se emplean como
un recurso de memoria. La coincidencia encontrada por esta parte del patrón es
almacenada para posterior uso

Utilizando patrones simples

Los patrones simples se construyen con caracteres para los que se desea una
coincidencia exacta. Por ejemplo, el patrón /abc/ coincidirá sólo con esta exacta
secuencia y orden de caracteres ('abc'). Tal expresión tendría resultados en las
cadenas "Hi, do you know your abc's?" y "Los últimos diseños de aviones
evolucionaron desde slabcraft." En ambos existe una coincidencia exacta con la
subcadena 'abc'. No hay coincidencia en la cadena 'Grab crab' debido a que, a
pesar de que contiene los caracteres 'a', 'b' y 'c', la sequencia 'abc' nunca
aparece.

Utilizando caracteres especiales

Cuando la búsqueda de coincidencias require algo más que una coincidencia

exacta, como por ejemplo el encontrar una o más 'b', o encontrar espacios en
blanco, se incluyen en el patrón caracteres especiales. Por ejemplo, el patrón
/ab*c/ coincidirá con cualquier sequencia de caracteres en la cual una 'a' preceda
a cualquier cantidad de 'b' (cero o más) y sea inmediatamente seguida por una
'c'. En la cadena 'cbbabbbbcdebc,' el patrón coincidirá con la subcadena
'abbbbc'.
La siguiente tabla ofrece una lista completa de los caracteres especiales que
pueden utilizarse en las expresiones regulares.

Caracteres especiales para expresiones regulares

carácter Significado
\ Buscará coincidencias conforme a las siguientes reglas:

Una barra invertida precediendo un carácter simple indica que éste

debe ser interpretado como un carácter especial y no de forma literal.
Por ejemplo, una 'b' sin '\' precediéndole coincidirá con cualquier 'b'
minúscula en la cadena, sin embargo, '\b' no coincidirá con algún
carácter en específico; representará el delimitador especial de
palabras.

^ Coincide con el principio de la entrada. Si la bandera de multilínea

está activada, también coincidirá inmediatamente después de un
salto de línea.
Por ejemplo, /^A/ no coincide con la 'A' en "an A", pero sí con la 'A'
en "An E".
El carácter '^' tiene un significado diferente cuando aparece como el
primer carácter en un patrón.
$ Busca el final de la entrada. Si la bandera de multilínea se establece
en true, también buscará inmediatamente antes de un carácter de
salto de línea.
Por ejemplo, la expresión /r$/ no encontrará el carácter 'r' en la
cadena "cenaremos", pero sí la encontrará en la cadena "cenar".
* Busca el carácter precedente 0 (cero) o más veces. Es equivalente a
{0,}.

Por ejemplo, la expresión /bo*/ encontrará la subcadena 'boooo' en

la cadena "A ghost booooed" y el carácter 'b' en la cadena "A bird
warbled", pero no encontrará nada en la cadena "A goat grunted".

+ Busca el carácter precedente 1 o más veces. Es equivalente a {1,}.

Por ejemplo, la expresión /u+/ encontrará el carácter 'u' en la cadena

"dulce" y todos los caracteres 'u' en la cadena "duuuuulce".
? Busca el carácter precedente 0 (cero) o 1 (una) vez. Es equivalente
a{0,1}.

Por ejemplo, la expresión /e?le?/ encontrará la subcadena 'el' en la

cadena "angel" y la subcadena 'le' en la cadena "angle" y también el
carácter Significado
carácter 'l' en la cadena "oslo".

Si se utiliza inmediatamente después que cualquiera de los

cuantificadores *, +, ?, o {}, hace que el cuantificador no sea
expansivo (encontrando la menor cantidad posible de caracteres), en
comparación con el valor predeterminado, que sí es expansivo
(encontrando tantos caracteres como le sea posible). Por ejemplo,
aplicando la expresión /\d+/ a la cadena "123abc" encuentra "123".
Pero aplicando la expresión /\d+?/ a la misma cadena, encuentra
solamente el carácter "1".

También se utiliza en coincidencias previsivas, como se describe en

las entradas x(?=y) y x(?!y) de esta tabla.

. (El punto decimal) coincide con cualquier carácter excepto

un carácter de nueva línea.

Por ejemplo , /.n/ coincide 'an' y 'on' en "nay, an apple is on the tree",
pero no 'nay'.

(x) Busca 'x' y recuerda la búsqueda, como el siguiente ejemplo lo

muestra. Los paréntesis son llamados paréntesis de captura.

El '(foo)' y '(bar)' en el patrón /(foo) (bar) \1 \2/ busca y recuerda las

primeras dos palabras en el string "foo bar foo bar". El \1 y \2 en el
patron coincida las dos últimas palabras de la cadena. Nota que \1,
\2, \n son usados en la parte donde se define la expresión regular.
Cuando se usan en la parte de reemplazo, se debe usar la
sintaxis $1, $2, $nen su lugar 'bar foo'.replace( /(...) (...)/, '$2 $1' ).
(?:x) Coincide con 'x' pero no recuerda la coincidencia. Los paréntesis son
llamados paréntesis no capturadores, y permiten definir
subexpresiones para manipular con los operadores de las
expresiones regulares. Considera la expresión de
ejemplo /(?:foo){1,2}/. Si la expresión fuera /foo{1,2}/, los
caracteres {1,2} se aplicarían sólo a la última 'o' en 'foo'. Con los
paréntesis no capturadores, {1,2} se aplica a la palabra entera 'foo'.
x(?=y) Coincide con 'x' sólo si 'x' es seguida por 'y'. Esto se denomina
previsión (lookahead, mirar adelante).

Por ejemplo, /Jack(?=Sprat)/ coincide con 'Jack' solo si es seguido

por 'Sprat'. /Jack(?=Sprat|Frost)/ conicide con 'Jack' solo si es
seguido por 'Sprat' o 'Frost'. Sin embargo, ni 'Sprat' ni 'Frost' serán
parte del resultado.
carácter Significado
x(?!y) Coincide con 'x' solo si 'x' no es seguida por 'y'. Es una previsión
negativa.

Por ejemplo, /\d+(?!\.)/ coincide con numeros solo si no vienen

seguidos por un punto decimal. La expresion
regular /\d+(?!\.)/.exec("3.141") coincide con '141' pero no con
'3.141'.
x|y Coincide con 'x' o 'y'.

Por ejemplo, /green|red/ coincide con 'green' en "green apple" y 'red'

en "red apple."
{n} Coincide exactamente con n ocurrencias de la expresión. N debe ser
un entero positivo.

Por ejemplo, /a{2}/ no coincide con la 'a' en "candy," pero si con las
a de "caandy," y las 2 primeras a en "caaandy."
{n,m} Donde n y m son enteros positivos y n <= m. Coincide con al
menos n y no más de m ocurrencias de la expresión. Si se omite m,
no tiene limite de máximo.
Por ejemplo, /a{1,3}/ no coincide con "cndy", pero sí con la 'a' en
"candy," las primeras 2 a en "caandy," y las primeras 3 a en
"caaaaaaandy". Note que en "caaaaaaandy", la coincidencia es
"aaa", aunque la cadena contenga más a en ella.
[xyz] Grupo de caracteres. Este tipo de patrón coincide con cada carácter
dentro de los corchetes, incluyendo secuencias de escapado.
Caracteres especiales como el punto (.) y el asterisco (*) no son
especiales en un grupo, así que no necesitan ser escapados. Puede
especificar un rango utilizando un guión, como en el siguiente
ejemplo.

El patrón [a-d], que equivale a [abcd], coincide con la 'b' en "brisket"

y la 'c' in "city". El patrón /[a-z.]+/ y /[\w.]+/ coinciden con toda la
cadena "test.i.ng".
[^xyz] Grupo de caracteres negativo. Significa que coincide con cualquier
cosa que no esté en los corchetes. Puede especificar rangos. Todo
lo que funciona en el grupo de caracteres positivo funciona también
aquí.

Por ejemplo, [^abc] es lo mismo que [^a-c], y coincide con la 'r' en

"brisket" y 'h' en "chop."
[\b] Coincide con backspace (U+0008). Debe ir entre corchetes. (No
confundir con \b.)
carácter Significado
\b Coincide con un limite de palabra. Un limite de palabra coincide con
la posicion entre donde un carácter de palabra no viene precedido o
seguido por otro. Notese que el límite no estará incluido en la
coincidencia. En otras palabras, la longitud del limite es cero. (No
confundir con [\b].)
Ejemplos:
/\bm/ coincide con la 'm' de "moon" ;
/oo\b/ no tiene coincidencias en "moon", porque las 'oo' estan
seguidas de una 'n' que es un carácter de palabra;
/oon\b/ coincide con 'oon' en "moon", porque 'oon' es el final de la
cadena, por lo cual no va seguido de un carácter de palabra;
/\w\b\w/ no coincidirá con nada, porque un carácter de palabra no
puede estar seguido por ambos, un limite y un carácter de palabra.
\B Coincide con un no-limite de palabra. Esto coincide con una posicion
donde el anterior y el siguiente carácter son del mismo tipo: ambos
son o no son caracteres de palabra. El inicio y el final de una cadena
se consideran no palabras.
Por ejemplo, /\B../ coincide con 'oo' en "noonday", y /y\B./ coincide
con 'ye' en "possibly yesterday."
\cX Donde X es un carácter entre A y Z. Coincide con un carácter de
control en un string.
Por ejemplo, /\cM/ coincide con control-M (U+000D) en un string.
\d Coincide con un carácter de número. Equivalente a [0-9].
Por ejemplo, /\d/ or /[0-9]/ coinciden con el '2' en "B2 is the suite
number."
\D Coincide con cualquier carácter no numérico. Equivalente a [^0-9].
Por ejemplo, /\D/ or /[^0-9]/ coincide con la 'B' en "B2 is the suite
number."
\f Coincide con un form feed (salto de página) (U+000C).
\n Coincide con un line feed (salto de linea) (U+000A).
\r Coincide con un carriage return (retorno de carro) (U+000D).
\s Coincide con un carácter de espacio, entreellos
incluidos espacio, tab, salto de página, salto de linea y retorno de
carro. Equivalente a[ \f\n\r\t\v\u00a0\u1680\u180e\u2000
\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008
\u2009\u200a\u2028\u2029\u202f\u205f\u3000].
Por ejemplo, /\s\w*/ coincide con ' bar' en "foo bar."
\S Coincide con todo menos caracteres de espacio. Equivalente a [^
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004
\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f
\u3000].
carácter Significado
Por ejemplo, /\S\w*/ coincide con 'foo' en "foo bar."
\t Coincide con tab (U+0009).
\v Coincide con tab vertical (U+000B).
\w Coincide con cualquier carácter alfanumérico, incluyendo el guión
bajo. Equivalente a [A-Za-z0-9_].
Por ejemplo, /\w/ coincide con 'a' en "apple," '5' en "$5.28," y '3' en
"3D."
\W Coincide con todo menos caracteres de palabra. Equivalente a [^A-
Za-z0-9_].
Por ejemplo, /\W/ o /[^A-Za-z0-9_]/ coinciden con '%' en "50%."
\n Cuando n es un entero positivo, es una referencia hacia alguna
subcadena de paréntesis dentro de la misma expresion que coincida
con el número (contando los paréntesis izquierdos).
Por ejemplo, /apple(,)\sorange\1/ coincide con 'apple, orange,' en
"apple, orange, cherry, peach."
\0 Coincide con el carácter NULL (U+0000). No preseda este por otro
número, ya que \0<numero> se considera una secuencia
octal escapada.
\xhh Coincide con un carácter en exadecimal hh (dos dígitos
hexadecimales)
\uhhhh Coincide con un carácter unicode con el código hhhh (cuatro dígitos
hexadecimales).

Usando paréntesis

Los paréntesis alrededor de alguna parte del patrón de la expresión regular

hacen que parte de la subcadena que coincida sea recordada. Una vez
recordada, puede ser rellamada en otro uso.

Por ejemplo, el patrón /Chapter (\d+)\.\d*/ ilustra caracteres de escape y

especiales adicionales e indica que parte del patrón debe recordarse. Coincide
con los caracteres 'Chapter ' seguidos por uno o más números, luego un punto
decimal, seguido por cualquier número 0 o más veces (para más detalles vea la
tabla 4.1). Además, se utilizaron paréntesis para recordar el primer grupo de
números.
Este patrón se encuentra dentro del string "Open Chapter 4.3, paragraph 6" y se
memoriza el '4'. El patrón no se encuentra en "Chapter 3 and 4", porque no
consigue el punto despues del '3'.
Si no quiere memorizar la subcadena, utilice ?: al inicio de los paréntesis. Por
ejemplo, (?:\d+) coincide con uno o más números pero no memoriza la
coincidencia.

Trabajando con Expresiones Regulares

Las expresiones regulares se utilizan con los métodos
de RegExp test y exec y con los metodos de String match, replace, search,
and split.
Métodos que utilizan expresiones regulares
Método Descripción
exec Un método RegExp que ejecuta una búsqueda por una coincidencia
en una cadena. Devuelve un array de información.
test Un método RegExp que verifica una coincidencia en una cadena.
Devuelve true o false.
match Un método String que ejecuta una búsqueda por una coincidencia
en una cadena. Devuelve un array deinformación o null si no existe
coincidencia alguna.
search Un método String que verifica una coincidencia en una
cadena. Devuelve el índice de la coincidencia, o -1 si la búsqueda
falla.
replace Un método String que ejecuta una búsqueda por una coincidencia
en una cadena, y reemplaza la subcadena encontrada con una
subcadena de reemplazo.
split Un método String que utiliza una expresión regular o una cadena fija
para cortar una cadena y colocarlo en un array de subcadenas.

Cuando quiera saber si un patrón se encuentra en una cadena, utilice los

métodos test o search. Para obtener más información (pero de ejecución más
lenta) utilice los métodos exec o match. Si usted utiliza exec o match y se logra
la coincidencia, estos métodos devuelven un array y actualizan las propiedades
del objeto de la expresión regular asociada y también aquellas del objeto de la
expresión regular predefinida, RegExp. Si la coincidencia falla, el
método exec devuelve null(que coacciona a false).
En el siguiente ejemplo, el script usa el método exec para buscar coincidencias
en un string.

var myRe = /d(b+)d/g;

var myArray = myRe.exec ( "cdbbdbsbz");

Si no necesita acceder a las propiedades de la expresión regular, una forma

alternativa de crear myArray es con este script:

var myArray = /d(b+)d/g.exec("cdbbdbsbz ");

Si quiere construir la expresión regular desde un String, otra alternativa es:

var myRe = new RegExp ( "d (b +) d", "g");
var myArray = myRe.exec ( "cdbbdbsbz");

Todos estos ejemplos tienen coincidencias, por lo que se retorna un array, y se

actualizan las propiedades mostradas en la siguiente tabla.

Resultados de la ejecución de la expresión regular.

Objeto Propiedad o índice Descripción En el ejemplo

my Array Las coincidencias y las ["dbbd", "bb"]

subcadenas memorizadas.
index La posición de la 1
coincidencia en la cadena de
entrada.
input La cadena original. "cdbbdbsbz"
[0] La última coincidencia de "dbbd"
caracteres.
myRe last Index La posición de donde iniciar 5
la próxima búsqueda.

(Esta propiedad solo es

seteada si la expresión

utiliza la opción g, descrita

source El texto del patrón. "d(b+)d"

Actualizado al momento de
creación, no al ejecutarse.

Como puede verse en la segunda línea de este ejemplo, puede usar una
expresión regular creada con un inicializador de objeto sin asignarse a una
variable. Si lo hace, sin embargo, cada ocurrencia será una nueva expresión
regular. Por esta razón, si usa este método sin asignarlo a una variable, no podrá
acceder posteriormente a las propiedades de estas expresiones regulares. Por
ejemplo, suponga que tiene el siguiente script:

var myRe = /d(b+)d/g;

var myArray = myRe.exec ( "cdbbdbsbz");
console.log ( "El valor de lastIndex es" + myRe.lastIndex);

El script mostrará:

El valor de lastIndex es 5

Sin embargo, si el script utilizado es éste:

var myArray = /d(b+)d/g.exec("cdbbdbsbz ");
console.log ( "El valor de lastIndex es" + /d(b+)d/g.lastIndex);

Se mostrará lo siguiente:

El valor de lastIndex es 0

Las apariciones de /d(b+)d/g en las dos sentencias son objetos de expresiones

regulares distintas y, por lo tanto, tienen diferentes valores en su
propiedad lastIndex. Si necesita acceder a las propiedades de una expresión
regular creada con un inicializador de objeto, deberá, previamente, asignarla a
una variable.

Indicadores de expresiones regulares.

Bandera Descripción
g Búsqueda global.
i Búsqueda 'case-insensitive' (no sensible a mayúsculas).
m Búsqueda en multi-línea.
u unicode; se trata el patrín como una secuencia de caracteres
unicode.
y Realizar una búsqueda de "pegajoso" que se ajuste a partir de la
posición actual en la cadena de destino.

DESARROLLE APLICACIONES DE EXPRESIONES REGULARES.

DAR EJEMPLOS DE LENGUAJE DE PROGRAMACION QUE UTILIZEN
DIRECTAMENTE EXPRESIONES REGUALES PARA VALIDACIONES DE
DATOS.
Expresiones Regulares Con Php
Ejemplo 1: Validar una Urls de Facebook
1. function valid_facebook_url($val) {
2. if(!preg_match('/^(http\:\/\/|https\:\/\/)?((w{3}\.)?)facebook\.com\/(?:#!\/)?(
?:pages\/)?(?:[\w\-\.]*\/)*([\w\-\.]*)+$/', $val))
3. {
4. return false;
5. }
6. return true;
7. }

Esta expresión regular dice que debe tener http: o https:((http\:\/\/|https\:\/\/)),

puede o no tener www.(((w{3}\.)?)), el interrogante dice que es opcional, pero
que si existe, debe contener las 3({3}).
Con (?:#!\/)? aceptamos opcionalmente un patrón como el siguiente #!/, esto es
útil para que los crawlers modernos sepan indexar Urls como las que trabajan
con aplicaciones monopágina como las creadas con angularjs.

Finalmente acepta opcionalmente el slug Pages muy típico de Facebook y otros

slugs con los caracteres permitidos por Facebook.

Ejemplo 2: Validar una Urls de Twitter

function valid_twitter_url($val)
{
if(!preg_match('/^(https?:\/\/)?((w{3}\.)?)twitter\.com\/(#!\/)?[a-z0-
9_]+$/', $val))
{
return false;
}
return true;
}

Esta es mucho más sencilla, como podemos ver acepta opcionalmente o bien
http o https seguido de ://(:\/\/), las contrabarras son para escapar, no hacen nada
más.

Seguidamente hace lo mismo que la Urls de Facebook, acepta opcionalmente #!

y además, cualquier cosa sin una longitud definida que contengo letras en
minúsculas de la a hasta la z y del 0 al 9, eso es todo, creo que esta es bastante
sencilla.

Validación con Expresiones Regulares en .NET

La clase String incluye varios métodos de búsqueda y reemplazo de cadenas
que puede usar cuando desee buscar cadenas literales en una cadena mayor.
Las expresiones regulares son muy útiles cuando se desea buscar una de varias
subcadenas en una cadena mayor o cuando se desea identificar patrones en
una cadena, como se muestra en los ejemplos siguientes.
Ejemplo 1: reemplazar subcadenas
Imports System.Text.RegularExpressions

Module Example
Public Sub Main()
Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
Dim names() As String = { "Mr. Henry Hunt", "Ms. Sara Samuels", _
"Abraham Adams", "Ms. Nicole Norris" }
For Each name As String In names
Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
Next
End Sub
End Module
' El ejemplo muestra la siguiente salida:
' Henry Hunt
' Sara Samuels
' Abraham Adams
' Nicole Norris

El patrón de expresión regular (Mr\.? |Mrs\.? |Miss |Ms\.? ) busca coincidencias

con cualquier aparición de "Mr ", "Mr. " , "Mrs ", "Mrs. " , "Miss ", "Ms o "Ms. " . La
llamada al método Regex.Replace reemplaza la cadena coincidente con
String.Empty; es decir, la quita de la cadena original.

Ejemplo 2: identificar palabras duplicadas

Duplicar palabras accidentalmente es un error frecuente que cometen los
escritores. Se puede usar una expresión regular para identificar palabras
duplicadas, como se muestra en el ejemplo siguiente.

Imports System.Text.RegularExpressions

Module modMain
Public Sub Main()
Dim pattern As String = "\b(\w+?)\s\1\b"
Dim input As String = "This this is a nice day. What about this? This tastes
good. I saw a a dog."
For Each match As Match In Regex.Matches(input, pattern,
RegexOptions.IgnoreCase)
Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
match.Value, match.Groups(1).Value, match.Index)
Next
End Sub
End Module
' El ejemplo muestra la siguiente salida:
' This this (duplicates 'This)' at position 0
' a a (duplicates 'a)' at position 66

El patrón de expresión regular \b(\w+?)\s\1\b se puede interpretar de la manera

siguiente:

\b Empieza en un límite de palabras.

(\w+?) Coincide con uno o más caracteres de palabra, pero con el menor
número de caracteres posible. Juntos, forman un grupo al que se
puede hacer referencia como \1.

\s Coincide con un carácter de espacio en blanco.

\1 Coincide con la subcadena que es igual al grupo denominado \1.

\b Coincide con un límite de palabras.

Se llama al método Regex.Matches con las opciones de expresiones regulares
establecidas en RegexOptions.IgnoreCase. Por tanto, la operación de
coincidencia no distingue mayúsculas de minúsculas y el ejemplo identifica la
subcadena "Esto esto" como una duplicación.
Observe que la cadena de entrada incluye la subcadena “this ? This". Sin
embargo, debido al signo de puntuación intermedio, no se identifica como una
duplicación.

Validación con Expresiones Regulares en JavaScript

En JavaScript, las expresiones regulares también son objetos. Estos patrones
son utilizados a través de los métodos exec y test de RegExp, así como los
métodos match, replace, search y split de String.
Método Descripción
exec Un método RegExp que ejecuta una búsqueda por una
coincidencia en una cadena. Devuelve un array de información.
test Un método RegExp que verifica una coincidencia en una cadena.
Devuelve true o false.
match Un método String que ejecuta una búsqueda por una coincidencia
en una cadena. Devuelve un array deinformación o null si no
existe coincidencia alguna.
replace Un método String que ejecuta una búsqueda por una coincidencia
en una cadena, y reemplaza la subcadena encontrada con una
subcadena de reemplazo.
split Un método String que utiliza una expresión regular o una cadena
fija para cortar una cadena y colocarlo en un array de subcadenas.
search Un método String que verifica una coincidencia en una
cadena. Devuelve el índice de la coincidencia, o -1 si la búsqueda
falla.
remplace
split

Cuando quiera saber si un patrón se encuentra en una cadena, utilice los

métodos test o search. Para obtener más información (pero de ejecución más
lenta) utilice los métodos exec o match. Si usted utiliza exec o match y se logra
la coincidencia, estos métodos devuelven un array y actualizan las propiedades
del objeto de la expresión regular asociada y también aquellas del objeto de la
expresión regular predefinida, RegExp. Si la coincidencia falla, el método exec
devuelve null (que coacciona a false).
En el siguiente ejemplo, el script usa el método exec para buscar coincidencias
en un string.
var myRe = /d(b+)d/g;
var myArray = myRe.exec ("cdbbdbsbz");