Cuantificadores
===============

Los cuantificadores indican el número de caracteres o expresiones que deben coincidir.

Pruébalo
--------

Tipos
-----

La siguiente tabla también está duplicada en `esta hoja de referencia`. No olvides editarla también, ¡gracias!

**Nota:** A continuación, *elemento* se refiere no solo a caracteres individuales, sino que también incluye `clases de caracteres`, `escapes de propiedades Unicode`, `grupos y rangos`.


| Caracteres | Significado |
| --- | --- |
| `*x**` | Concuerda 0 o más veces con el elemento "x" anterior. Por ejemplo, `/bu*/` coincide con "buuuu" en "Un fantasma abuuuucheado" y "b" en "Un búho gorjeó", pero nada en "Una cabra gruñó". |
| `*x*+` | Encuentra 1 o más 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 después de cualquiera de los cuantificadores `*`, `+`, `?`, o `{}`, hace que el cuantificador *no sea codicioso* (es decir que coincida con el mínimo número de veces), a diferencia del predeterminado, que es codicioso (que coincide con el máximo número de veces). |
| `*x*{*n*}` | Donde "n" es un número 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 número 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 número entero positivo, "m" es un número entero positivo y `*m* > *n*` coincide con al menos "n" y como máximo "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 tenía más "*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 `?` después 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 "algún <foo> <bar> nuevo </bar> </foo>":* `/<.*>/` coincidirá con "<foo> <bar> nuevo </bar> </foo>"
* `/<.*?>/` coincidirá con "<foo>"
 |

Ejemplos
--------

### Patrón repetido


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

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

### Conteo de caracteres


```js
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


```js
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


```js
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 interrogación
console.log(texto.match(regexpNoCodiciosa));
// "D"
// La coincidencia es la más pequeña posible
```

Especificaciones
----------------

{{Specifications}}Compatibilidad del navegador
----------------------------

Para obtener información sobre la compatibilidad del navegador, consulta la `tabla principal de compatibilidad de expresiones regulares`.

Ve también
----------

* `Guía de expresiones regulares`
    + `Clases de caracteres`
    + `Aserciones`
    + `Escapes de propiedades Unicode`
    + `Grupos y rangos`
* `El constructor RegExp()`