RegExp

El objeto RegExp se utiliza para hacer coincidir texto con un patr贸n.

Para obtener una introducci贸n a las expresiones regulares, lee el cap铆tulo sobre expresiones regulares en la Gu铆a de JavaScript.

Descripci贸n

Notaci贸n literal y constructor

Hay dos formas de crear un objeto RegExp: una notaci贸n literal y un constructor.

  • Los par谩metros de la notaci贸n literal se encierran entre barras y no utilizan comillas.
  • Los par谩metros de la funci贸n constructora no se encierran entre barras, pero utilizan comillas.

Las siguientes tres expresiones crean el mismo objeto de expresi贸n regular:

let er = /ab+c/i; // notaci贸n literal
let er = new RegExp('ab+c', 'i') // constructor con patr贸n de cadena como primer argumento
let er = new RegExp(/ab+c/, 'i') // constructor con expresi贸n regular literal como primer argumento (a partir de ECMAScript 6)

La notaci贸n literal da como resultado la compilaci贸n de la expresi贸n regular cuando se eval煤a la expresi贸n. Utiliza la notaci贸n literal cuando la expresi贸n regular permanecer谩 constante. Por ejemplo, si usas notaci贸n literal para construir una expresi贸n regular usada en un bucle, la expresi贸n regular no se volver谩 a compilar en cada iteraci贸n.

El constructor del objeto de expresi贸n regular, por ejemplo, new RegExp('ab+c'), da como resultado la compilaci贸n en tiempo de ejecuci贸n de la expresi贸n regular. Utiliza la funci贸n constructora cuando sepas que el patr贸n de expresi贸n regular cambiar谩, o no conozcas el patr贸n y lo obtienes de otra fuente, tal como la entrada del usuario.

Banderas en el constructor

A partir de ECMAScript 6, new RegExp(/ab+c/, 'i') ya no arroja un TypeError ("no puedes proporcionar banderas cuando construyes una expresi贸n regular a partir de otra") cuando el primer argumento es una RegExp y el segundo argumento flags est谩 presente. En su lugar, se crea una nueva RegExp a partir de los argumentos.

Cuando se utiliza la funci贸n constructora, las reglas de escape de cadenas normales (antes de los caracteres especiales con \ cuando se incluyen en una cadena) son necesarias.

Por ejemplo, los siguientes son equivalentes:

let er = /\w+/
let er = new RegExp('\\w+')

Propiedades de expresiones regulares similares a Perl

Ten en cuenta que varias de las propiedades de RegExp tienen nombres largos y cortos (tipo Perl). Ambos nombres siempre se refieren al mismo valor. (Perl es el lenguaje de programaci贸n a partir del cual JavaScript model贸 sus expresiones regulares). Consulta tambi茅n las propiedades en desuso de RegExp

Constructor

RegExp()
Crea un nuevo objeto RegExp.

Propiedades est谩ticas

get RegExp[@@species]
La funci贸n constructora utilizada para crear objetos derivados.
RegExp.lastIndex
El 铆ndice en el que comenzar谩 la siguiente b煤squeda.

Propiedades de la instancia

RegExp.prototype.flags
Una cadena que contiene las banderas del objeto RegExp.
RegExp.prototype.dotAll
Si el "." coincide con nuevas l铆neas o no.
RegExp.prototype.global
Si se debe probar o no la expresi贸n regular con todas las posibles ocurrencias en una cadena, o solo con la primera.
RegExp.prototype.ignoreCase
Si se deben o no ignorar las may煤sculas/min煤sculas al buscar en una cadena.
RegExp.prototype.multiline
Si buscar o no en cadenas multil铆nea.
RegExp.prototype.source
El texto del patr贸n.
RegExp.prototype.sticky
Si la b煤squeda es pegajosa o no.
RegExp.prototype.unicode
Si las funciones Unicode est谩n habilitadas o no.

M茅todos de instancia

RegExp.prototype.compile()
(Re)compila una expresi贸n regular durante la ejecuci贸n de un script.
RegExp.prototype.exec()
Ejecuta una b煤squeda de una coincidencia en su par谩metro de cadena.
RegExp.prototype.test()
Prueba una coincidencia en su par谩metro de cadena.
RegExp.prototype.toString()
Devuelve una cadena que representa el objeto especificado. Redefine el m茅todo Object.prototype.toString().
RegExp.prototype[@@match]()
Realiza la coincidencia con la cadena dada y devuelve el resultado de la coincidencia.
RegExp.prototype[@@matchAll]()
Devuelve todas las coincidencias de la expresi贸n regular con una cadena.
RegExp.prototype[@@replace]()
Reemplaza las coincidencias en una cadena dada con una nueva subcadena.
RegExp.prototype[@@search]()
Busca la coincidencia en la cadena dada y devuelve el 铆ndice del patr贸n encontrado en la cadena.
RegExp.prototype[@@split]()
Divide la cadena dada en un arreglo separando la cadena en subcadenas.

Ejemplos

Usar una expresi贸n regular para cambiar el formato de los datos

El siguiente script usa el m茅todo replace() de la instancia String para hacer coincidir una nombre en el formato primero 煤ltimo y enviarlo en el formato 煤ltimo, primero.

En el texto de reemplazo, el script usa $1 y $2 para indicar los resultados de los correspondientes par茅ntesis coincidentes en el patr贸n de expresi贸n regular.

let er = /(\w+)\s(\w+)/
let str = 'John Smith'
let newstr = str.replace(er, '$2, $1')
console.log(newstr)

Esto muestra "Smith, John".

Uso de expresiones regulares para dividir l铆neas con diferentes finales de l铆nea/saltos de l铆nea

El final de l铆nea predeterminado var铆a seg煤n la plataforma (Unix, Windows, etc.). La divisi贸n de l铆neas proporcionada en este ejemplo funciona en todas las plataformas.

let texto = 'Un poco de texto\ny un poco m谩s\r\ny a煤n\reste es el final'
let lineas = texto.split(/\r\n|\r|\n/)
console.log(lineas) // logs [ 'Un poco de texto', 'y un poco m谩s', 'y a煤n', 'este es el final' ]

Ten en cuenta que el orden de los patrones en la expresi贸n regular es importante.

Usar expresiones regulares en varias l铆neas

let s = '隆Por favor, s铆\nhazme el d铆a!'

s.match(/s铆.*d铆a/);
// Devuelve null

s.match(/s铆[^]*d铆a/);
// Devuelve ["s铆\nhazme el d铆a"]

Usar una expresi贸n regular con la bandera pegajosa

La bandera sticky indica que la expresi贸n regular realiza una coincidencia permanente en la cadena de destino al intentar hacer coincidir a partir de RegExp.prototype.lastIndex.

let str = '#foo#'
let regex = /foo/y

regex.lastIndex = 1
regex.test(str)      // true
regex.lastIndex = 5
regex.test(str)      // false (lastIndex se tiene en cuenta con una bandera pegajosa)
regex.lastIndex      // 0 (restablecer despu茅s de un error de coincidencia)

La diferencia entre la bandera pegajosa y la bandera global

Con la bandera pegajosa y, la siguiente coincidencia tiene que ocurrir en la posici贸n lastIndex, mientras que con la bandera global g, la coincidencia puede ocurrir en la posici贸n lastIndex o posterior:

er = /\d/y;
while (r = re.exec("123 456")) console.log(r, "Y er.lastIndex", er.lastIndex);

// [ '1', index: 0, input: '123 456', groups: undefined ] AND er.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND er.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND er.lastIndex 3
//   ... y no m谩s coincidencias.

Con la bandera global g, coincidir铆an los 6 d铆gitos, no solo 3.

Expresi贸n regular y caracteres Unicode

\w y \W solo coincide con caracteres basados en ASCII; por ejemplo, a a z, A a Z, 0 a 9 y _.

Para hacer coincidir caracteres de otros idiomas como Cir铆lico o Hebreo, usa \uhhhh, donde hhhh es el Valor Unicode en hexadecimal.

Este ejemplo demuestra c贸mo se pueden separar los caracteres Unicode de una palabra.

let texto = '袨斜褉邪蟹械褑 texto 薪邪 褉褍褋褋泻芯屑 褟蟹褘泻械'
let regex = /[\u0400-\u04FF]+/g

let match = regex.exec(text)
console.log(match[0])        // registra '袨斜褉邪蟹械褑'
console.log(regex.lastIndex) // registra '7'

let match2 = regex.exec(texto)
console.log(match2[0])       // registra '薪邪' [no registr贸 'texto']
console.log(regex.lastIndex) // registra '15'

// y as铆 sucesivamente

La funci贸n Escapes de propiedad Unicode presenta una soluci贸n, al permitir una declaraci贸n tan simple como \p{scx=Cyrl}.

Extraer el nombre de subdominio de la URL

let url = 'http://xxx.dominio.com'
console.log(/[^.]+/.exec(url)[0].substr(7)) // registra 'xxx'

En lugar de utilizar expresiones regulares para analizar las URL, normalmente es mejor utilizar el analizador de URL integrado en los navegadores mediante la API URL.

Especificaciones

Compatibilidad del navegador

BCD tables only load in the browser

Notas espec铆ficas de Firefox

A partir de Firefox 34, en el caso de un grupo de captura con cuantificadores que impiden su ejercicio, el texto coincidente para un grupo de captura ahora es undefined en lugar de una cadena vac铆a:

// Firefox 33 o anterior
'x'.replace(/x(.)?/g, function(m, group) {
  console.log("'grupo: " + group + "'");
});
// 'grupo: '

// Firefox 34 o m谩s reciente
'x'.replace(/x(.)?/g, function(m, group) {
  console.log("'grupo: " + group + "'");
});
// 'grupo: undefined'

Ten en cuenta que, debido a la compatibilidad web, RegExp.$N seguir谩 devolviendo una cadena vac铆a en lugar de undefined (error 1053944).

Ve tambi茅n