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

O método **`exec()`** executa a busca por um padrão em uma determinada string. Retorna um array, ou `null`.

Se você está precisa somente de um retorno verdadeiro/falso, use o método `RegExp.prototype.test()` ou `String.prototype.search()`.

Sintaxe
-------
```

regexObj.exec(string)
```

### Parâmetros

`string`

A string para comparar com a expressão regular

### Valor retornado

Se a combinação acontecer, o método `exec()` o método retorna um array e atualiza as propriedades do objeto da expressão regular. Esse array retornado possui o texto combinado como primeiro item e depois um item para cada captura contendo o respectivo texto.

Se falhar, o retorno do método `exec()` será `null`.

Descrição
---------

Considere o exemplo abaixo:


```js
// Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles
// Relembra "brown" e "jumps"
// Ignora caixa (maiúsculo e minúsculo)
var re = /quick\s(brown).+?(jumps)/gi;
var result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
```


A tabela a seguir provê os resultados do script:

|  |  |  |  |
| --- | --- | --- | --- |
| Objeto | Propriedade/Índice | Descrição | Exemplo |
| `result` | `[0]` | A string completa dos caracteres encontrados | `Quick Brown Fox Jumps` |
| `[1], ...[*n* ]` | 
 As combinações de substrings parametrizadas encontradas, se existir. A
 quantidade de possíveis substrings parametrizadas é ilimitado.
  | `[1] = Brown[2] = Jumps` |
| `index` | O índice base 0 do valor encontrado na string. | `4` |
| `input` | String original | `The Quick Brown Fox Jumps Over The Lazy Dog` |
| `re` | `lastIndex` | 
 O índice que começa a próxima combinação encontrada. Quando
 "`g`" não é definido, este valor será sempre 0.
  | `25` |
| `ignoreCase` | 
 Indica se a flag "`i`" foi usada para ignorar caixa
 alta/baixa.
  | `true` |
| `global` | 
 Indica se a flag "`g`" foi usada para encontrar combinações
 de forma global.
  | `true` |
| `multiline` | 
 Indica se a flag "`m`" foi usada para pesquisar em strings de
 diversas linhas.
  | `false` |
| `source` | Texto do padrão. | `quick\s(brown).+?(jumps)` |

Exemplos
--------

### Procurando combinações sucessivas

If your regular expression uses the "`g`" flag, you can use the `exec()` method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of `str` specified by the regular expression's `lastIndex` (en-US) property (`test()` will also advance the `lastIndex` (en-US) property). For example, assume you have this script:


```js
var myRe = /ab\*/g;
var str = "abbcdefabh";
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
  var msg = "Found " + myArray[0] + ". ";
  msg += "Next match starts at " + myRe.lastIndex;
  console.log(msg);
}
```


This script displays the following text:
```

Found abb. Next match starts at 3
Found ab. Next match starts at 9
```


Nota: Do not place the regular expression literal (or `RegExp` constructor) within the `while` condition or it will create an infinite loop if there is a match due to the `lastIndex` (en-US) property being reset upon each iteration. Also be sure that the global flag is set or a loop will occur here also.

### Usando `exec()` com `RegExp` literais

You can also use `exec()` without creating a `RegExp` object:


```js
var matches = /(hello \S+)/.exec("This is a hello world!");
console.log(matches[1]);
```


This will log a message containing 'hello world!'.

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* O capítulo de Expressões Regulares no Guia de Javascript.
* `RegExp`