RegExp
======

Sumário
-------

O construtor **`RegExp`** cria um objeto de expressão regular para realizar uma correspondência de texto com um padrão.

Para uma introdução à expressões regulares, leia o capítulo de Expressões Regulares no Guia de JavaScript.

Construtor
----------

Notações literais e de construtores são possíveis:
```

/padrão/flags
new RegExp(padrão[, flags])
RegExp(padrão[, flags])
```

### Parâmetros

`padrão`

O texto da expressão regular, ou como em ES5, outro objeto RegExp. Os padrões podem incluir caracteres especiais para correspondencia em um intervalo maior de valores do que uma string literal.

`flags`

Se especificado, `flags`indica os marcadores que podem ser adicionados, ou se um objeto é suficiente para o padrão, os valores de flags serão substituidos por qualquer uma das flags de objetos. O valor de `flags`é uma string contendo qualquer combinação dos seguintes valores:

`g`

corresponder globalmente; acha **todas** as correspondências em vez de parar após achar a primeira

`i`

ignorar maiúsc./minúsc.; Se a *flag `u`* estiver ativa, deve ser utilizado o *Unicode case folding*

`m`

multilinha; trata caracteres de início e fim (^ e $) ao operar sobre múltiplas linhas (ou seja, corresponder o início ou fim de *cada* linha (delimitado por \n ou \r), e não apenas o começo ou fim de toda a string de entrada)

`u` 
Experimental

unicode; trata o padrão como uma sequência de código unicode

`y` 
Experimental

aderente; corresponde apenas pelo index indicado pela propriedade `lastIndex` dessa expressão regular na string alvo (e não tenta corresponder de qualquer indexes posteriores).


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

Há dois modos de criar um objeto `RegExp`: uma notação literal e um construtor. Para indicar strings, os parâmetros para a notação literal não usam aspas, enquanto os parâmetros para a função do construtor usam. Então, as seguintes expressões criam a mesma expressão regular:


```js
/ab+c/i;
new RegExp("ab+c", "i");
```


A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um *loop*, a expressão regular não será recompilada a cada iteração

O construtor do objeto da expressão regular, por exemplo, `new RegExp('ab+c')`, fornece uma compilação em tempo de execução da expressão regular. Use a função construtora quando você sabe que o padrão da expressão regular será mudado, ou você não sabe o padrão e o está recebendo de outra fonte, como uma entrada do usuário.

Começando com ECMAScript 6, `new RegExp(/ab+c/, 'i')`, deixou de lançar um `TypeError` ("can't supply flags quando constructing one RegExp from another") quando o primeiro argumento é um `RegExp` e o segundo argumento `flags` está presente. Uma nova `RegExp` dos argumentos é criada ao invés disso.

Quando se usa a função construtora, as regras de escapar em uma string (preceder caracteres especiais com \ quando incluídos na string) são necessárias. Por exemplo, as declarações a seguir são equivalentes:


```js
var re = /\w+/;
var re = new RegExp("\\w+");
```

Significado dos caracteres especiais nas expressões regulares
-------------------------------------------------------------

* Classes de Caracteres
* Conjuntos de Caracteres
* Limites
* Agrupamentos e back references
* Quantificadores

| Classes de Caracteres |
| --- |
| Caractere | Significado |
| `.` | 
 (O ponto) corresponde um único caracter qualquer *exceto* os
 caracteres de nova linha: `\n`, `\r`,
 `\u2028` ou `\u2029`.


 Note que a flag multilinha `m` não muda o comportamento do
 ponto. Então para corresponder um padrão por múltiplas linhas, o
 conjunto de caracteres `[^]` pode ser usado, que
 corresponderá qualquer caractere, incluindo novas linhas.


 Por exemplo, `/.y/` corresponde "my" e "ay", mas não "yes",
 em "yes make my day".
  |
| `\d` | 
 Corresponde um caractere de dígito no alfabeto basic Latin.
 Equivalente `a [0-9]`.


 Por exemplo, `/\d/` ou `/[0-9]/` corresponde "2"
 em "B2 é o número da suíte".
  |
| `\D` | 
 Corresponde qualquer caractere que não é um dígito no alfabeto basic
 Latin. Equivalente a `[^0-9]`.


 Por exemplo, `/\D/` ou `/[^0-9]/` corresponde
 "B" em "B2 é o suite number".
  |
| `\w` | 
 Corresponde qualquer caractere alfanumérico do alfabeto basic Latin,
 incluindo o underline. Equivalente a `[A-Za-z0-9_]`.


 Por exemplo, `/\w/` corresponde "a" em "apple", "5" em
 "$5.28", e "3" em "3D".
  |
| `\W` | 
 Corresponde qualquer caractere que não é um alfanumérico do alfabeto
 basic Latin. Equivalente a `[^A-Za-z0-9_]`.


 Por exemplo, `/\W/` ou
 `/[^A-Za-z0-9_]/` corresponde "%" em "50%".
  |
| `\s` | 
 Corresponde um único caractere de espaço em branco, incluindo espaço,
 tabulação (tab), quebra de página, nova linha (LF) e outros espaços
 Unicode. Equivalente a
 `[
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

Por exemplo, `/\s\w*/` corresponde " bar" em "foo bar". |
| `\S` | 
 Corresponde um único caractere que não seja um espaço em branco.
 Equivalente a
 `[^
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

Por exemplo, `/\S\w*/` corresponde "foo" em "foo bar". |
| `\t` | Corresponde uma tabulação. |
| `\r` | Corresponde uma quebra de linha. |
| `\n` | Corresponde uma nova linha. |
| `\v` | Corresponde uma tabulação vertical. |
| `\f` | Corresponde uma quebra de página. |
| `[\b]` | Corresponde um caracter backspace. (Não confundir com `\b`) |
| `\0` | Corresponde um caractere NUL. Não coloque outro dígito seguinte a esse. |
| `\c*X*` | 
 Onde `*X*` é uma letra de A - Z. Corresponde um
 caractere de controle em uma string.

Por exemplo, `/\cM/` corresponde control-M em uma string. |
| `\x*hh*` | 
 Corresponde o caractere com o código `*hh*` (dois
 dígitos hexadecimais).
  |
| `\u*hhhh*` | 
 Corresponde o caractere com o valor Unicode
 `*hhhh*` (quatro dígitos hexadecimais).
  |
| `\` | 
 Para caracteres que são geralmente tratados literalmente, indica que o
 próximo caractere é especial e não deve ser interpretado literalmente.


 Por exemplo, `/b/` corresponde o caractere "b". Colocando
 uma barra invertida antes do "b", ou seja, usando `/\b/`, o
 caractere se torna especial, significando corresponder o limite de uma
 palavra.

*ou*

 Para caracteres que são geralmente tratados especialmente, indica que
 o próximo caractere não é especial e deve ser interpretado
 literalmente.


 Por exemplo, "\*" é um caractere especial que significa 0 ou mais
 ocorrências do caractere precedente devem ser correspondidas; por
 exemplo, `/a*/` significa corresponder 0 ou mais "a"s. Para
 corresponder `*` literalmente, preceda-o com uma barra
 invertida; por exemplo, `/a\*/` corresponde "a\*".
  |
| Conjuntos de Caracteres |
| --- |
| Caractere | Significado |
| `[xyz]` | 
 Um conjunto de caracteres. Corresponde qualquer um dos caracteres
 cercados. Você pode especificar uma extensão de caracteres usando um
 hífen.


 Por exemplo, `[abcd]` é o mesmo que `[a-d]`.
 Eles correspondem o "b" em "banco" e o "c" em "cortar".
  |
| `[^xyz]` | 
 Um conjunto de caracteres negativo ou complementado. Isto é,
 corresponde qualquer coisa que não esteja cercada nos colchetes. Você
 pode especificar uma extensão de caracteres usando um hífen.


 Por exemplo, `[^abc]` é o mesmo que `[^a-c]`.
 Eles inicialmente correspondem "n" em "banco" e "o" em "cortar".
  |
| Limites |
| --- |
| Caractere | Significado |
| `^` | 
 Corresponde o início de uma entrada. Se a flag multilinha é utilizada,
 também corresponde imediatamente após um caractere de quebra de linha.


 Por exemplo, `/^A/` não corresponde o "A" em "an A", mas
 corresponde o primeiro "A" em "An A".
  |
| `$` | 
 Corresponde o fim de uma entrada. Se a flag multilinha é utilizada,
 também corresponde imediatamente antes de um caractere de quebra de
 linha.


 Por exemplo, `/o$/` não corresponde o "o" em "cantor", mas
 corresponde em "canto".
  |
| `\b` | 
 Corresponde um limite de palavra de largura zero, como entre uma letra
 e um espaço. (Não confundir com `[\b]`)


 Por exemplo, `/\bno/` corresponde o "no" em "de noite";
 `/ly\b/` corresponde o "ly" em "possibly yesterday".
  |
| `\B` | 
 Corresponde um limite de uma não palavra de largura zero, como entre
 duas letras ou entre dois espaços.


 Por exemplo, `/\Bte/` corresponde "te" em "de noite", e
 `/on\B/` corresponde "on" em "possivelmente ontem".
  |
| Agrupamentos e back references |
| --- |
| Caractere | Significado |
| `(*x*)` | 
 Corresponde `*x*` e memoriza a correspondência.
 Esses são chamados parênteses de captura.


 Por exemplo, `/(foo)/` corresponde e memoriza "foo" em "foo
 bar". A substring correspondida pode ser chamada novamente dos
 elementos do array resultante `[1], ..., [n]` ou das
 propriedades predefinidas do objeto `RegExp`
`$1, ..., $9`.


 Grupos de captura têm uma falta na performance. Se você não necessita
 que a substring correspondida seja chamada novamente, prefira
 parênteses de não-captura (veja mais abaixo).
  |
| `\*n*` | 
 Onde `*n*` é um inteiro positivo. A back reference
 to o last substring matching o n parenthetical no expressão regular
 (counting left parentheses).


 Por exemplo, `/apple(,)\sorange\1/` corresponde "apple,
 orange," em "apple, orange, cherry, peach". Um exemplo mais completo
 está a seguir nesta tabela.
  |
| `(?:*x*)` | 
 Corresponde `*x*` mas não memoriza a correspondência.
 Esses são chamados parênteses de não-captura. A substring correspondida
 não pode ser chamada novamente dos elementos do array resultante
 `[1], ..., [n]` ou das propriedades predefinidas do objeto
 `RegExp` `$1, ..., $9`.
  |
| Quantificadores |
| --- |
| Caractere | Significado |
| `*x**` | Corresponde o item precedente *x* zero ou mais vezes.

 Por exemplo, `/assusto*/` corresponde "assustoooo" em "Um
 fantasma assustoooou" e "assust" em "Não me assustei", mas nada em "Um
 bode grunhiu".


 Note que no caso acima, o único caractere a ser selecionado é "o",
 pois ele é o caractere imediatamente anterior ao asterisco e não há
 qualquer operador de agrupamento que indique que mais caracteres
 deveriam ser submetidos à repetição. Se quiséssemos selecionar a
 ocorrência sequencial da palavra completa "blah", por exemplo,
 poderíamos utilizar algum agrupamento como `/(blah)*/` o
 que geraria a seleção de "blahblahblah" na frase "blahblahblah ração
 para gatos" ou de "blah" na frase "algoritmo blahut-arimoto".
  |
| `*x*+` | 
 Corresponde o item precedente *x* uma ou mais vezes.
 Equivalente a `{1,}`.


 Por exemplo, `/a+/` corresponde o "o" em "doce" e todos os
 "o"s em "doooooooce".
  |
| `*x*?` | Corresponde o item precedente *x* nenhuma ou uma vez.

 Por exemplo, `/e?le?/` corresponde o "el" em "angel" e o
 "le" em "angle."


 If used imediatamente after qualquer dos quantifiers `*`,
 `+`, `?`, ou `{}`, makes o quantifier
 non-greedy (matching o minimum number of vezes), como opposed to o
 default, which é greedy (matching o maximum number of vezes).


 Also used em lookahead assertions, described under `(?=)`,
 `(?!)`, e `(?:)` em this table.
  |
| `*x*(?=*y*)` | 
 Corresponde `*x*` apenas se `*x*` é
 seguido por `*y*`. Por exemplo, `/Jack(?=Sprat)/` corresponde "Jack" apenas
 se for seguido por "Sprat".
 `/Jack(?=Sprat|Frost)/` corresponde "Jack" apenas se for
 seguido por "Sprat" ou "Frost". Porém, nem "Sprat" nem "Frost" são
 partes do resultado da correspondência.
  |
| `*x*(?!*y*)` | 
 Corresponde `*x*` apenas se
 `*x*` não é seguido por `*y*`. Por exemplo, `/\d+(?!\.)/` corresponde um número apenas
 se não for seguido por um ponto.


`/\d+(?!\.)/.exec('3.141')` corresponde "141", mas não
 "3.141".
  |
| `*x*|*y*` | Corresponde `*x*`ou `*y*`*.*

 Por exemplo, `/verde|vermelha/` corresponde "verde" em
 "maçã verde" e "vermelha" em "maçã vermelha".


 Entretanto, a primeira expressão tem preferência. Se uma string fosse
 corresponder às duas expressões, ela vai corresponder à que aparece do
 lado esquerdo do operador `|`. Por exemplo,
 `/maçãs|maçã/` corresponde "maçãs" na frase "*maçãs*
 vermelhas" e "maçã" na frase "*maçã* verde".
  |
| `*x*{*n*}` | 
 Onde `*n*` é um número inteiro positivo. Corresponde
 exatamente `*n*` ocorrências do item precedente
 *x*.


 Por exemplo, `/o{2}/` não corresponde o "o" em
 "brigadeiro", mas corresponde todos os dois "o"s em
 "brigadeir*oo*", e o dois primeiros "o"s em
 "brigadeir*oo*o".
  |
| `*x*{*n*,}` | 
 Onde `*n*` é um número inteiro positivo. Corresponde
 *pelo menos* `*n*` ocorrências do item
 precedente *x* (sem que haja um limite superior).


 Por exemplo, `/o{2,}/` não corresponde o "o" em
 "brigadeiro", mas corresponde todos os "o"s em "brigadeir*oo*" e
 em "brigadeir*ooooooooo*".
  |
| `*x*{*n*,*m*}` | 
 Onde `*n*` e `*m*` são números
 inteiros positivos. Corresponde pelo menos `*n*` e
 no máximo `*m*` ocorrências do item precedente
 *x*.


 Por exemplo, `/o{2,4}/` corresponde nada em "brigadeiro",
 os dois "o"s em "brigadeir*oo*", os três "o"s em
 "brigadeir*ooo*", e os primeiros quatro "o"s em
 "brigadeir*oooo*o".


 É importante perceber que no último caso a correspondência não inclui
 o último "o" de "brigadeirooooo". Isso se deve ao fato do operador
 quantificador ter definido o número máximo de ocorrências como 4,
 ignorando a quinta repetição do caractere.
  |
| `*x**?``*x*+?*x??**x{n,}?**x{n,m}?*` | 
**Operadores *non-greedy* ou *lazy* (não-gulosos ou
preguiçosos)**Esses operadores com a `?` no final, operam de
 maneira semelhante aos seus análogos sem `?` mostrados
 acima, correspondendo múltiplas ocorrências do item precedente
 *x.* Entretanto, desta vez a ocorrência selecionada será a
 mínima possível.


 No exemplo `/(blah)*?/`, diante da frase "blahblahblah
 ração para gatos", nada seria selecionado, pois a ocorrência mínima
 aceita pelo operador `*?` seria ocorrência de 0 (zero)
 vezes da *string* "blah", o que resulta no nada.


 Já a expressão regular `/(blah)+?/`, diante da mesma frase,
 corresponderia a "blah", que é a ocorrência mínima aceita pelo
 operador `+?`*,* ou seja, 1 (uma) repetição da
 sequência "blah".


 Em outro exemplo com mais aplicação prática, digamos que se quer
 corresponder todos os termos que ficam entre aspas em um texto. Se
 fizéssemos simplesmente a *regex* `/".*"/`, diante
 de um texto com múltiplas ocorrências de termos entre aspas, como:
 *'Eu "gosto" muito de "estudar" regex'*, a nossa expressão
 regular seria gulosa e selecionaria o maior texto possível que
 correspondesse à definição, nesse caso, selecionando '*"gosto" muito de "estudar"*', pois todo esse texto está compreendido entre a primeira aspa
 (antes de *'gosto'*) e a última aspa (após *'estudar'*),
 o que é um resultado talvez indesejado.Se usarmos a regex
 `/".*?"/`, com o operador não-guloso, as correspondências
 para a mesma frase seriam '*"gosto"*' e '*"estudar"*'
 separadamente, conforme era a intenção inicial.
  |

Propriedades
------------

`RegExp.prototype` (en-US)

Permite a adição de propriedades a todos os objetos.

`RegExp.length`

O valor of `RegExp.length` é 2.

Métodos
-------

O objeto global `RegExp não possui métodos próprios, no entanto, herda alguns métodos através da cadeia de prototype.`

Objetos e instancias
--------------------

### Propriedades

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Properties')}}### Métodos

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Methods')}}Exemplos
--------

### Exemplo: Usando uma expressão regular para mudar o fomato dos dados

O seguinte script usa o método `replace()` da instância de `String` para casar o nome no format *nome sobrenome* e produzir no formato *sobrenome, nome*. No texto substituto, o script usa `$1` e `$2` para indicar os respectivos parênteses de casamento no padrão da expressão regular.


```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
```


Isto retornará "Smith, John".

### Exemplo: Usando expressões regulares para quebrar linhas com diferentes **fins de linha**/**quebras de linha**

O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(*split*) de linha fornecida neste exemplo funciona com todas as plataformas.


```js
var text = "Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim";
var lines = text.split(/\r\n|\r|\n/);
console.log(lines); // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ]
```


Note que a ordem dos padrões na expressão regular importa.

### Exemplo: Usando expressão regular sobre múltiplas linhas


```js
var s = "Please yes\nmake my day!";
s.match(/yes.\*day/);
// Retorna null
s.match(/yes[^]\*day/);
// Retorna'yes\nmake my day'
```

### Exemplo: Using a expressão regular com o "sticky" flag

Este exemplo mostra como utilizar a sticky flag em expressões regulares.


```js
var text = "First line\nSecond line";
var regex = /(\S+) line\n?/y;

var match = regex.exec(text);
console.log(match[1]); // prints 'First'
console.log(regex.lastIndex); // prints '11'

var match2 = regex.exec(text);
console.log(match2[1]); // prints 'Second'
console.log(regex.lastIndex); // prints '22'

var match3 = regex.exec(text);
console.log(match3 === null); // prints 'true'
```


One can test at run-time whether o sticky flag é supported, using `try { … } catch { … }`. Para this, either an `eval(…)` expression ou o `RegExp(regex-string, flags-string)` syntax must be used (since o `/regex/flags` notation é processed at compile-time, so throws an exception before o `catch` block é encountered). Por exemplo:


```js
var supports_sticky;
try {
  RegExp("", "y");
  supports_sticky = true;
} catch (e) {
  supports_sticky = false;
}
console.log(supports_sticky); // prints 'true'
```

### Exemplo: Expressão regular e Unicode caracteres

As mentioned above, `\w` ou `\W` only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "\_". To match caracteres from other languages such como Cyrillic ou Hebrew, use `\uhhhh`, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra.


```js
var text = "Образец text на русском языке";
var regex = /[\u0400-\u04FF]+/g;

var match = regex.exec(text);
console.log(match[0]); // prints 'Образец'
console.log(regex.lastIndex); // prints '7'

var match2 = regex.exec(text);
console.log(match2[0]); // prints 'на' [não print 'text']
console.log(regex.lastIndex); // prints '15'

// e assim vai
```


Here's an external resource para getting o complete Unicode block range para different scripts: Regexp-unicode-block.

### Exemplo: Extracting subdomain name from URL


```js
var url = "http://xxx.domain.com";
console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-regular-expression-objects |

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

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

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

* Regular Expressions chapter no JavaScript Guide
* `String.prototype.match()`
* `String.prototype.replace()`