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, flagsindica 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
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.
\cX

Onde X é uma letra de A - Z. Corresponde um caractere de controle em uma string.

Por exemplo, /\cM/ corresponde control-M em uma string.

\xhh Corresponde o caractere com o código hh (dois dígitos hexadecimais).
\uhhhh 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 "brigadeiroo", e o dois primeiros "o"s em "brigadeirooo".

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 "brigadeiroo" e em "brigadeirooooooooo".

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 "brigadeiroo", os três "o"s em "brigadeirooo", e os primeiros quatro "o"s em "brigadeirooooo".

É 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

Veja também