Expresiones Regulares

Las expresiones regulares son patrones que se utilizan para hacer coincidir combinaciones de caracteres en cadenas. En JavaScript, las expresiones regulares tambi茅n son objetos. Estos patrones se utilizan con los m茅todos exec() y test() de RegExp, y con match(), matchAll(), replace(), replaceAll(), search() y split() m茅todos de String. Este cap铆tulo describe las expresiones regulares de JavaScript.

Crear una expresi贸n regular

Construyes una expresi贸n regular en una de estas dos formas:

  • Usando una expresi贸n regular literal, que consiste en un patr贸n encerrado entre barras, como sigue:

    let re = /ab+c/;
    

    Las expresiones regulares literales proporcionan la compilaci贸n de la expresi贸n regular cuando se carga el script. Si la expresi贸n regular permanece constante, su uso puede mejorar el rendimiento.

  • O llamando a la funci贸n constructora del objeto RegExp, de la siguiente manera:

    let re = new RegExp('ab+c');
    

    El uso de la funci贸n constructora proporciona una compilaci贸n en tiempo de ejecuci贸n de la expresi贸n regular. Usa la funci贸n constructora cuando sepas que el patr贸n de la expresi贸n regular cambiar谩, o no conoces el patr贸n y lo obtienes de otra fuente, como la entrada del usuario.

Escribir 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 /Cap铆tulo (\d)\.\d*/. El 煤ltimo ejemplo incluye par茅ntesis, que se utilizan como dispositivos de memoria. La coincidencia realizada con esta parte del patr贸n se recuerda para su uso posterior, como se describe en Uso de grupos.

Nota: Si ya est谩s familiarizado con las formas de una expresi贸n regular, tambi茅n puedes leer la hoja de referencia para una b煤squeda r谩pida de un patr贸n/construcci贸n espec铆fica.

Usar patrones simples

Los patrones simples se construyen con caracteres para los que deseas encontrar una coincidencia directa. Por ejemplo, el patr贸n /abc/ coincide con combinaciones de caracteres en cadenas solo cuando ocurre la secuencia exacta "abc" (todos los caracteres juntos y en ese orden). Tal coincidencia tendr铆a 茅xito en las cadenas "Hola, 驴conoces tu abc?" y "Los 煤ltimos dise帽os de aviones evolucionaron a partir de slabcraft". En ambos casos, la coincidencia es con la subcadena "abc". No hay ninguna coincidencia en la cadena "Grab crab" porque aunque contiene la subcadena "ab c", no contiene la subcadena "abc" exacta.

Usar caracteres especiales

Cuando la b煤squeda de una coincidencia requiere algo m谩s que una coincidencia exacta, como por ejemplo buscar una o m谩s 'b', o encontrar espacios en blanco, puedes incluir caracteres especiales en el patr贸n. Por ejemplo, para hacer coincidir una sola "a" seguida de cero o m谩s "b"s seguidas de "c", usar铆as el patr贸n /ab*c/: el * despu茅s de "b" significa "0 o m谩s apariciones del elemento anterior". En la cadena "cbbabbbbcdebc", este patr贸n coincidir谩 con la subcadena "abbbbc".

Las siguientes p谩ginas proporcionan listas de los diferentes caracteres especiales que encajan en cada categor铆a, junto con descripciones y ejemplos.

Aserciones
Las aserciones incluyen l铆mites, que indican el comienzo y el final de l铆neas y palabras, y otros patrones que indican de alguna manera que el reconocimiento es posible (incluidas las expresiones anticipadas, inversas y condicionales).
Clases de caracteres
Distingue diferentes tipos de caracteres. Por ejemplo, distinguir entre letras y d铆gitos.
Grupos y rangos
Indica grupos y rangos de caracteres de expresi贸n.
Cuantificadores
Indica el n煤mero de caracteres o expresiones que deben coincidir.
Escapes de propiedades Unicode
Distinguir seg煤n las propiedades de los caracteres Unicode, por ejemplo, letras may煤sculas y min煤sculas, s铆mbolos matem谩ticos y de puntuaci贸n.

Si deseas ver todos los caracteres especiales que se pueden usar en expresiones regulares en una sola tabla, consulta lo siguiente:

Caracteres especiales en expresiones regulares.
Caracteres/construcciones Art铆culo correspondiente
\, ., \cX, \d, \D, \f, \n, \r, \s, \S, \t, \v, \w, \W, \0, \xhh, \uhhhh, \uhhhhh, [\b]

Clases de caracteres

^, $, x(?=y), x(?!y), (?<=y)x, (?<!y)x, \b, \B

Aserciones

(x), (?:x), (?<Name>x)x|y, [xyz], [^xyz], \Number

Grupos y rangos

*, +, ?, x{n}, x{n,}, x{n,m}

Cuantificadores

\p{UnicodeProperty}, \P{UnicodeProperty} Escapes de propiedades Unicode

Nota: Tambi茅n est谩 disponible una hoja de referencia m谩s grande (solo agregando partes de esos art铆culos individuales).

Escapando

Si necesitas usar literalmente cualquiera de los caracteres especiales (en realidad buscando un "*", por ejemplo), lo debes escapar colocando una barra invertida delante de 茅l. Por ejemplo, para buscar "a" seguido de "*" seguido de "b", usar铆as /a\*b/ 鈥 la barra invertida "escapa" de "*", volvi茅ndola literal en lugar de especial.

De manera similar, si est谩s escribiendo un literal de expresi贸n regular y necesitas buscar una barra inclinada ("/"), la debes escapar (de lo contrario, esta termina el patr贸n). Por ejemplo, para buscar la cadena "/ejemplo/" seguida de uno o m谩s caracteres alfab茅ticos, usar铆as /\/ejemplo\/[a-z]+/i: las barras invertidas antes de cada barra, las hace literales.

Para hacer coincidir una barra invertida literal, debes escapar de la barra invertida. Por ejemplo, para encontrar la cadena "C:\" donde "C" puede ser cualquier letra, usar铆as /[A-Z]:\\/ 鈥 la primera barra invertida escapa a la que sigue, por lo que la expresi贸n busca una sola barra invertida literal.

Si usas el constructor RegExp con un literal de cadena, recuerda que la barra invertida es un escape en los literales de cadena, por lo que para usarlo en la expresi贸n regular, debes escapar en el nivel del literal de cadena. /a\*b/ y new RegExp("a\\*b") crean la misma expresi贸n, que busca "a" seguida de un "*" literal seguido de "b".

Si las cadenas de escape a煤n no forman parte de tu patr贸n, puedes agregarlas usando String.replace:

function escapeRegExp(string) {
  return string.replace(/[.*+\-?^${}()|[\]\\]/g,'\\$&'); // $& significa toda la cadena coincidente
}

La "g" despu茅s de la expresi贸n regular es una opci贸n o indicador que realiza una b煤squeda global, buscando en toda la cadena y devolviendo todas las coincidencias. Se explica en detalle a continuaci贸n en B煤squeda avanzada con indicadores.

驴Por qu茅 no est谩 integrada en JavaScript? Existe una propuesta para agregar esta funci贸n a RegExp, pero fue rechazada por TC39.

Usando par茅ntesis

Los par茅ntesis alrededor de cualquier parte del patr贸n de expresi贸n regular hacen que se recuerde esa parte de la subcadena coincidente. Una vez reconocida, la subcadena se puede recuperar para otro uso. Consulta Grupos y rangos para obtener m谩s detalles.

Usar expresiones regulares en JavaScript

Las expresiones regulares se utilizan con los m茅todos RegExp test() y exec() y con los m茅todos de String, match(), replace(), search() y split(). Estos m茅todos se explican en detalle en la referencia de JavaScript.

M茅todos que usan expresiones regulares
M茅todo Descripci贸n
exec() Ejecuta una b煤squeda por una coincidencia en una cadena. Devuelve un arreglo de informaci贸n o null en una discrepancia.
test() Prueba una coincidencia en una cadena. Devuelve true o false.
match() Devuelve un arreglo que contiene todas las coincidencias, incluidos los grupos de captura, o null si no se encuentra ninguna coincidencia.
matchAll() Devuelve un iterador que contiene todas las coincidencias, incluidos los grupos de captura.
search() Prueba una coincidencia en una cadena. Devuelve el 铆ndice de la coincidencia, o -1 si la b煤squeda falla.
replace() Ejecuta una b煤squeda por una coincidencia en una cadena y reemplaza la subcadena coincidente con una subcadena de reemplazo.
replaceAll() Ejecuta una b煤squeda de todas las coincidencias en una cadena y reemplaza las subcadenas coincidentes con una subcadena de reemplazo.
split() Utiliza una expresi贸n regular o una cadena fija para dividir una cadena en un arreglo de subcadenas.

Cuando desees saber si un patr贸n se encuentra en una cadena, utiliza los m茅todos test() o search(); para obtener m谩s informaci贸n (pero una ejecuci贸n m谩s lenta) utiliza los m茅todos exec() o match(). Si usas exec() o match() y si la b煤squeda tiene 茅xito, estos m茅todos devuelven un arreglo y actualizan las propiedades del objeto expresi贸n regular asociado y tambi茅n del objeto de expresi贸n regular predefinido, el objeto RegExp. Si la b煤squeda falla, el m茅todo exec() devuelve null (que coacciona a false).

En el siguiente ejemplo, el script utiliza el m茅todo exec() para encontrar una coincidencia en una cadena.

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

Si no necesitas 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');
    // similar a "cdbbdbsbz" .match(/d(b+)d/g); sin embargo,
    // "cdbbdbsbz" .match (/d(b+)d/g) genera Array ["dbbd"], mientras
    // /d(b+)d/g.exec('cdbbdbsbz ') produce Array ['dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ].

(Consulta diferentes comportamientos para obtener m谩s informaci贸n sobre los diferentes comportamientos).

Si deseas construir la expresi贸n regular a partir de una cadena, otra alternativa m谩s es este script:

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

Con estos scripts, la b煤squeda se realiza correctamente, devuelve el arreglo y actualiza las propiedades que se muestran en la siguiente tabla.

Resultado de la ejecuci贸n de expresiones regulares.
Objeto Propiedad o 铆ndice Descripci贸n En este ejemplo
myArray La cadena coincidente y todas las subcadenas recordadas. ['dbbd', 'bb', index: 1, input: 'cdbbdbsbz']
铆ndice El 铆ndice basado en 0 de la coincidencia en la cadena de entrada. 1
entrada La cadena original. 'cdbbdbsbz'
[0] Los 煤ltimos caracteres encontrados. 'dbbd'
myRe lastIndex El 铆ndice en el que comenzar谩 la siguiente b煤squeda. (Esta propiedad se establece solo si la expresi贸n regular usa la opci贸n g, descrita en B煤squeda avanzada con banderas). 5
fuente El texto del patr贸n. Actualizado en el momento en que se crea la expresi贸n regular, no se ejecuta. 'd(b+)d'

Como se muestra en la segunda forma de este ejemplo, puedes usar una expresi贸n regular creada con un iniciador de objeto sin asignarla a una variable. Sin embargo, si lo hace, cada aparici贸n es una nueva expresi贸n regular. Por este motivo, si utilizas esta forma sin asignarla a una variable, no podr谩s acceder posteriormente a las propiedades de esa expresi贸n regular. Por ejemplo, supongamos que tienes este script:

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

// "El valor de lastIndex es 5"

Sin embargo, si tienes este script:

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

// "El valor de lastIndex es 0"

Las apariciones de /d(b+)d/g en las dos declaraciones son objetos de expresi贸n regular diferentes y, por lo tanto, tienen valores diferentes para su propiedad lastIndex. Si necesitas acceder a las propiedades de una expresi贸n regular creada con un iniciador de objeto, primero debes asignarla a una variable.

B煤squeda avanzada con banderas

Las expresiones regulares tienen seis indicadores opcionales que permiten funciones como la b煤squeda global y que no distinga entre may煤sculas y min煤sculas. Estos indicadores se pueden usar por separado o juntos en cualquier orden y se incluyen como parte de la expresi贸n regular.

Indicadores de expresi贸n regular
Bandera Descripci贸n Propiedad correspondiente
g B煤squeda global. RegExp.prototype.global
i B煤squeda que no distingue entre may煤sculas y min煤sculas. RegExp.prototype.ignoreCase
m B煤squeda multil铆nea. RegExp.prototype.multiline
s Permite que el . coincida con caracteres de nueva l铆nea. RegExp.prototype.dotAll
u "unicode"; tratar un patr贸n como una secuencia de puntos de c贸digo Unicode. RegExp.prototype.unicode
y Realiza una b煤squeda "pegajosa" que coincida a partir de la posici贸n actual en la cadena de destino. Consulta sticky. RegExp.prototype.sticky

Para incluir una bandera con la expresi贸n regular, usa esta sintaxis:

var re = /patr贸n/banderas;

o

var re = new RegExp('patr贸n', 'banderas');

Ten en cuenta que las banderas son parte integral de una expresi贸n regular. No se pueden agregar ni eliminar m谩s tarde.

Por ejemplo, re = /\w+\s/g crea una expresi贸n regular que busca uno o m谩s caracteres seguidos de un espacio y busca esta combinaci贸n en toda la cadena.

var re = /\w+\s/g;
var str = 'fee fi fo fum';
var myArray = str.match(re);
console.log(myArray);

// ["fee ", "fi ", "fo "]

Podr铆as reemplazar la l铆nea:

var re = /\w+\s/g;

con:

var re = new RegExp('\\w+\\s', 'g');

y obtener el mismo resultado.

El comportamiento asociado con el indicador g es diferente cuando se usa el m茅todo .exec(). Los roles de "clase" y "argumento" se invierten: En el caso de .match(), la clase cadena (o tipo de datos) posee el m茅todo y la expresi贸n regular es solo un argumento, mientras que en el caso de .exec(), es la expresi贸n regular la que posee el m茅todo, siendo la cadena el argumento. Compara esto str.match(re) con re.exec(str). El indicador g se usa con el m茅todo .exec() para obtener una progresi贸n iterativa.

var xArray; while(xArray = re.exec(str)) console.log(xArray);
// produce:
// ["fee ", index: 0, input: "fee fi fo fum"]
// ["fi ", index: 4, input: "fee fi fo fum"]
// ["fo ", index: 7, input: "fee fi fo fum"]

La bandera m se utiliza para especificar que una cadena de entrada de varias l铆neas se debe tratar como varias l铆neas. Si se usa el indicador m, ^ y $ coinciden al principio o al final de cualquier l铆nea dentro de la cadena de entrada en lugar del inicio o el final de toda la cadena.

Ejemplos

Nota: Tambi茅n hay varios ejemplos disponibles en:

Usar caracteres especiales para verificar la entrada

BCD tables only load in the browser

En el siguiente ejemplo, se espera que el usuario ingrese un n煤mero de tel茅fono. Cuando el usuario presiona el bot贸n "Comprobar", el script verifica la validez del n煤mero. Si el n煤mero es v谩lido (encuentra la secuencia de caracteres especificada por la expresi贸n regular), la secuencia de comandos muestra un mensaje agradeciendo al usuario y confirmando el n煤mero. Si el n煤mero no es v谩lido, el gui贸n informa al usuario que el n煤mero de tel茅fono no es v谩lido.

Entre par茅ntesis que no capturan (?:, la expresi贸n regular busca tres caracteres num茅ricos \d{3} O | un par茅ntesis izquierdo \( seguido de tres d铆gitos \d{3}, seguido de un par茅ntesis cerrado \), (finaliza el par茅ntesis no capturador )), seguido de un gui贸n, una barra diagonal o un punto decimal y cuando lo encuentre, recuerde el car谩cter ([-\/\.]), seguido de tres d铆gitos \d{3}, seguido de la coincidencia recordada de un gui贸n, una barra diagonal o un punto decimal \1, seguida de cuatro d铆gitos \d{4}.

El evento Change activado cuando el usuario presiona Enter establece el valor de RegExp.input.

HTML

<p>
  Ingresa tu n煤mero de tel茅fono (con el c贸digo de 谩rea) y luego haz clic en "Comprobar".
  <br>
  El formato esperado es como ###-###-####.
</p>
<form action="#">
  <input id="phone">
    <button onclick="testInfo(document.getElementById('phone'));">Comprobar</button>
</form>

JavaScript

var re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;
function testInfo(phoneInput) {
  var OK = re.exec(phoneInput.value);
  if (!OK) {
    console.error(phoneInput.value + ' isn\'t a phone number with area code!');
  } else {
    console.log('Gracias, tu n煤mero de tel茅fono es ' + OK[0]);}
} 

Resultado

Probador de expresiones regulares
Un constructor/depurador de expresiones regulares en l铆nea
Visualizador de expresiones regulares
Un probador de expresiones regulares visual en l铆nea.
Especificaci贸n
ECMAScript (ECMA-262)
La definici贸n de 'RegExp' en esta especificaci贸n.