From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../reference/global_objects/regexp/index.html | 636 +++++++++++++++++++++ 1 file changed, 636 insertions(+) create mode 100644 files/pt-br/web/javascript/reference/global_objects/regexp/index.html (limited to 'files/pt-br/web/javascript/reference/global_objects/regexp/index.html') diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..99ff4a626d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,636 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - Construtor + - Expressões Regulares + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +
{{JSRef("Global_Objects", "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_inline}}
+
unicode; trata o padrão como uma sequência de código unicode
+
+ +
+
y {{experimental_inline}}
+
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:

+ +
/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 {{jsxref("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:

+ +
var re = /\w+/;
+var re = new RegExp('\\w+');
+
+ +

Significado dos caracteres especiais nas expressões regulares

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Classes de Caracteres
CaractereSignificado
. +

(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".

+
\tCorresponde uma tabulação.
\rCorresponde uma quebra de linha.
\nCorresponde uma nova linha.
\vCorresponde uma tabulação vertical.
\fCorresponde uma quebra de página.
[\b]Corresponde um caracter backspace. (Não confundir com \b)
\0Corresponde 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.

+
\xhhCorresponde o caractere com o código hh (dois dígitos hexadecimais).
\uhhhhCorresponde 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
CaractereSignificado
[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
CaractereSignificado
^ +

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
CaractereSignificado
(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
CaractereSignificado
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

+ +
+
{{jsxref("RegExp.prototype")}}
+
Permite a adição de propriedades a todos os objetos.
+
RegExp.length
+
O valor of RegExp.length é 2.
+
+ +
{{jsOverrides("Function", "Properties", "prototype")}}
+ +

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.

+ +
{{jsOverrides("Function", "Methods", "prototype")}}
+ +

Objetos e instancias

+ +

Propriedades

+ +
{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Properties')}}
+ +

Métodos

+ +
{{page('/en-US/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 {{jsxref("String.prototype.replace()", "replace()")}} da instância de {{jsxref("Global_Objects/String", "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.

+ +
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.

+ +
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

+ +
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.

+ +
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:

+ +
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.

+ +
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

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

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
ECMAScript 1st Edition.StandardInitial definition. Implemented em JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}{{Spec2('ES6')}}
+ +

Compatibilidade de navegador

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Sticky flag ("y"){{CompatChrome("39")}} (behind flag){{CompatGeckoDesktop("1.9")}} ES4-Style {{bug(773687)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Sticky flag ("y"){{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("1.9")}} ES4-Style {{bug(773687)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Veja também

+ + -- cgit v1.2.3-54-g00ecf