Viewing: developer.mozilla.org

Prubalo

const ghostSpeak = "booh boooooooh";
const regexpSpooky = /bo{3,}h/;
console.log(ghostSpeak.match(regexpSpooky));
// Expected output: Array ["boooooooh"]

const modifiedQuote = "[He] ha[s] to go read this novel [Alice in Wonderland].";
const regexpModifications = /\[.*?\]/g;
console.log(modifiedQuote.match(regexpModifications));
// Expected output: Array ["[He]", "[s]", "[Alice in Wonderland]"]

const regexpTooGreedy = /\[.*\]/g;
console.log(modifiedQuote.match(regexpTooGreedy));
// Expected output: Array ["[He] ha[s] to go read this novel [Alice in Wonderland]"]

Tipos

La siguiente tabla tambin est duplicada en esta hoja de referencia. No olvides editarla tambin, gracias!

Nota: A continuacin, elemento se refiere no solo a caracteres individuales, sino que tambin incluye clases de caracteres, escapes de propiedades Unicode, grupos y rangos.

Caracteres	Significado
`x*`	Concuerda 0 o ms veces con el elemento "x" anterior. Por ejemplo, `/bu*/` coincide con "buuuu" en "Un fantasma abuuuucheado" y "b" en "Un bho gorje", pero nada en "Una cabra gru".
`x+`	Encuentra 1 o ms veces el elemento "x" anterior Equivalente a `{1,}`. Por ejemplo, `/a+/` coincide con la "a" en "candy" y todas las "a"es en "caaaaaaandy".
`x?`	Halla 0 o 1 vez el elemento "x" anterior. Por ejemplo, `/e?le?/` coincide con "el" en "ngel" y "ele" en "ngeles". Si se usa inmediatamente despus de cualquiera de los cuantificadores ``, `+`, `?`, o `{}`, hace que el cuantificador no sea codicioso* (es decir que coincida con el mnimo nmero de veces), a diferencia del predeterminado, que es codicioso (que coincide con el mximo nmero de veces).
`x{n}`	Donde "n" es un nmero entero positivo, concuerda exactamente con "n" apariciones del elemento "x" anterior. Por ejemplo, `/a{2}/` no coincide con la "a" de "candy", pero coincide con todas las "a"es de "caandy" y las dos primeras "a"es en "caaandy".
`x{n,}`	Donde "n" es un nmero entero positivo, concuerda con al menos "n" apariciones del elemento "x". Por ejemplo, `/a{2,}/` no coincide con las "a"es en "caramelo", pero coincide con todas las "a"es en "caaraamelo" y en "caaaaaaaraaaamelo".
`x{n,m}`	Donde "n" es 0 o un nmero entero positivo, "m" es un nmero entero positivo y `m > n` coincide con al menos "n" y como mximo "m" apariciones del elemento "x" anterior. Por ejemplo, `/a{1,3}/` no coincide con nada en "crmelo", la "a" en "carmelo", las dos "a"es en "caarmelo" y las tres primeras "a"es en "caaaaaaarmelo". Observa que al comparar "caaaaaaarmelo", encuentra las "aaa", aunque la cadena original tena ms "a"es.
`x*?` `x+?` `x??` `x{n}?` `x{n,}?` `x{n,m}?`	De manera predeterminada, los cuantificadores como `` y `+` son "codiciosos", lo cual significa que intentan hacer coincidir la mayor cantidad posible de la cadena. El caracter `?` despus del cuantificador hace que el cuantificador "no sea codicioso": lo cual significa que se detendr tan pronto como encuentre una coincidencia. Por ejemplo, dada una cadena como "algn <foo> <bar> nuevo </bar> </foo>": `/<.>/` coincidir con "<foo> <bar> nuevo </bar> </foo>" `/<.*?>/` coincidir con "<foo>"

Ejemplos

Patrn repetido

var palabraTerminadaConAes = /\w+a+\b/;
var mensajeDelicado = "Esto es Espartaaaaaaa";

console.table(mensajeDelicado.match(palabraTerminadaConAes)); // [ "Espartaaaaaaa" ]

Conteo de caracteres

var palabraDeUnaLetra = /\b\w\b/g;
var palabraNoTanLarga = /\b\w{1,6}\b/g;
var palabraLaaaaarga = /\b\w{10,}\b/g;

var frase =
  "Por qu me tengo que sentar a estudiar las tablas de multiplicar?";

console.table(frase.match(palabraDeUnaLetra)); // ["a"]
console.table(frase.match(palabraNoTanLarga)); // ["Por", "qu", "me", "tengo", "que", "sentar", "a", "las", "tablas", "de"]
console.table(frase.match(palabraLaaaaarga)); // ["multiplicar"]

Caracter opcional

var londinText = "He asked his neighbour a favour.";
var yanquiText = "He asked his neighbor a favor.";

var regexpEnding = /\w+ou?r/g;
// \w+ Una o varias letras
// o   seguida de una "o",
// u?  opcionalmente seguida de una "u"
// r   seguida de una "r"

console.table(londinText.match(regexpEnding));
// ["neighbour", "favour"]

console.table(yanquiText.match(regexpEnding));
// ["neighbor", "favor"]

Codicioso versus no codicioso

var texto = "Debo estar muy cerca del centro de la tierra.";
var regexpCodiciosa = /[\w ]+/;
// [\w ]      una letra del alfabeto latino o un espacio en blanco
//      +     una o varias veces

console.log(texto.match(regexpCodiciosa)[0]);
// "Debo estar muy cerca del centro de la tierra."
// casi todo el texto coincide (omite el caracter de punto)

var regexpNoCodiciosa = /[\w ]+?/; // Observa el signo de interrogacin
console.log(texto.match(regexpNoCodiciosa));
// "D"
// La coincidencia es la ms pequea posible