RegExp.prototype.exec()
=======================

El método **`exec()`** ejecuta una busqueda sobre las coincidencias de una expresión regular en una cadena especifica. Devuelve el resultado como array, o `null`.

Si está ejecutando una expresión regular solo para buscar si algo se cumple o no, usa el método `RegExp.prototype.test()` o el método `String.prototype.search()`.

Sintaxis
--------
```

regexObj.exec(cadena)
```

### Parametros

`cadena`

Cadena sobre la cual se quiere aplicar la expresión regular

### Valor devuelto

Si se encuentran coincidencial, el método `exec()` devuelve un array y actualiza las propiedades del objeto de la expresión regular. El array devuelto contiene los elementos encontrados en su primer elemento, y un elemento por cada parte de la expresión regular que se encuentra entre parentesis y se encuentra dentro del texto que fué capturado.

Si la busqueda falla, el método `exec()` devuelve `null`.

Descripción
-----------

Considerando el siguiente ejemplo:


```js
// Busca "quick brown" seguido de "jumps", ignorando los caracteres que se
// encuentren entre medias.
// Recuerda "brown" y "jumps"
// Ignora mayusculas y minusculas
var re = /quick\s(brown).+?(jumps)/gi;
var result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
```


La siguiente tabla muestra el resultado de este script:

|  |  |  |  |
| --- | --- | --- | --- |
| Objeto | Propiedad/Índice | Descripción | Ejemplo |
| `result` | `[0]` | Todas las partes de la cadena que cumplen la expresión regular | `Quick Brown Fox Jumps` |
| `[1],...[*n*]` | 
 Las subcadenas entre parentesis que han sido encontradas, si hay
 alguna. El número de subcadenas encontradas es ilimitado
  | `[1] = Brown[2] = Jumps` |
| `index` | El índice de base-0 del elemento encontrado en la cadena. | `4` |
| `input` | La cadena original. | `The Quick Brown Fox Jumps Over The Lazy Dog` |
| `re` | `lastIndex` | 
 El índice sobre el cual empieza la siguiente busqueda. Cuando no se usa
 g (busqueda global), esto va a ser siempre 0.
  | `25` |
| `ignoreCase` | 
 Indica si la bandera "`i`" ha sido usada para ignorar
 mayusculas y minusculas.
  | `true` |
| `global` | 
 Indica si la bandera "`g`" fue usada para hacer una busqueda
 global.
  | `true` |
| `multiline` | 
 Indica si la bandera "`m"` fue usada para buscar en cadenas
 sobre multiples lineas
  | `false` |
| `source` | El texto del patrón de busqueda | `quick\s(brown).+?(jumps)` |

Ejemplos
--------

### Encontrando coincidencias sucesivas

Si tu expresión regular contiene la bandera "`g`", puedes usar el método `exec()` varias veces para encontrar coincidencias sucesivas en la misma cadena. Cuando lo haces, la busqueda empieza en la subcadena `str` especificada por la propiedad `lastIndex` (en-US) de la expresión regular (`test()` también movera hacia adelante el indice de la propiedad `lastIndex` (en-US)). Por ejemplo, asumiendo que tienes este script:


```js
var myRe = /ab\*/g;
var str = "abbcdefabh";
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
  var msg = "Se ha encontrado " + myArray[0] + ". ";
  msg += "La siguiente coincidencia empieza en el indice " + myRe.lastIndex;
  console.log(msg);
}
```


Este script muestra el siguiente texto:
```

Se ha encontrado abb. La siguiente coincidencia empieza en el indice 3
Se ha encontrado ab. La siguiente coincidencia empieza en el indice 9
```


Nota: No uses la expresión regular literalmente (o el constructor `RegExp`) dentro de la condición del bucle while o se creará un bucle infinito si hay una coincidencia, por culpa de que la propiedad `lastIndex` (en-US) va a ser reiniciada por cada iteración del bucle. Además asegurate de que has usado la bandera de busqueda global "g" o se creará un bucle también.

### Usando `exec()` con `RegExp` literales

También se puede usar `exec()` sin crear un objeto de `RegExp`:


```js
var matches = /(hola \S+)/.exec("Esto es un hola mundo!");
console.log(matches[1]);
```


Esto logueará un mensaje que contiene 'hola mundo!'.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.exec |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* Capítulo de Expresiones Regulares en la Guía de Javascript
* `RegExp`