Expressões regulares, também chamadas de regex (de regular expression), são meios de descrever padrões que podem ser encontrados dentro de um texto. Os padrões podem ser simples, como a busca de um ou dois dígitos especificados, ou padrões complexos que incluem a posição do padrão no texto, o número de repetições, etc.
Regex são usados basicamente para a busca de um padrão, substituição de texto, validação de formatos e filtragem de informações. Praticamente todas as linguagens de programação possuem ferramentas de uso de regex, assim como grande parte dos editores de texto. As diferentes linguagens de programação e aplicativos que incorporam funcionalidade de regex possuem sintaxes ligeiramente diferentes, cada uma, mas há uma embasamento geral que serve a todas. Existem aplicativos de teste de regex em diversas plataformas e aplicativos online para o mesmo fim.
Exemplos de uso são:
- filtragem de linhas de um texto longo com determinados caracteres no início, meio ou fim da linha;
- remoção de tags de um texto escrito em html, com possível seleção dentro de uma tag determinada;
- validação de texto para representar datas e horas;
- validação de texto digitado pelo usuário para representar CPF, email, URL, CEP, cartão de crédito, etc;
- extração de dados de um arquivo csv, json, XML, markdown ou outro formato estruturado qualquer.
Usaremos, por concisão, a expressão sensível (insensivel) ao caso significando sensível (insensivel) à minúsculas e maiúsculas.
Tags do HTML são comandos de formatação de texto envolvidos por dois sinais < >
. Alguns exemplos são
<p>um parágrafo</p>
, <b>letras em negrito</b>
, etc.
Dizemos que um determinado padrão regex é procurado no texto até que ocorra um ou mais “casamentos” (match, em inglês). Por exemplo, o padrão ab é encontrado (e, portanto, casa com) os textos abraço, absolvido ou aberração, mas não casa com asbestos
. Se for pedida uma busca insensível ao caso, ele também casa com Abraço ou ABROLHOS. Em todo esse artigo marcaremos as partes “casadas” pela essa formatação especial.
Nos exemplos e tabelas desse artigo há uma certa quantidade de repetições, buscando facilitar o aprendizado. Tabelas enxutas para consultas serão listadas em outra parte.
Caracteres simples ou conjuntos de caracteres (strings comuns) são casados literalmente.
padrão | significado | exemplo: | casa ou não com |
---|---|---|---|
a |
caracter comum | a | casa Afazer aaa |
ab |
grupos de caracteres comuns | ab | absoluto abraço Abcd trabalho |
em 1945 |
caracteres alfanuméricos | em 1945 | a segunda guerra mundial terminou em 1945. |
Metacaracteres
Claro que não precisaríamos de nenhuma tecnologia especial para encontrar letras ou conjuntos de letras. Para construir padrões mais complexos usamos os metacaracteres (o que significa que têm significados especiais):
. * ^ $ + ? { } [ ] \ | ( )
.
O ponto (.
) representa (substitui ou casa com) qualquer caracter único.
padrão | casa com | não casa com |
---|---|---|
p.ata |
prata, plata | pata pirata |
lu.a |
luta, luma | lua lucca |
phylos.net |
phylos.net, phylos-net (1) | phylosnet |
(1): O ponto (.
) casa com todos os caracteres, inclusive o próprio ponto.
Quantificadores
Os quantificadores * ? + {}
permitem o controle de quantas repetições de um padrão ocorrem.
O asterisco *
representa zero, uma ou várias repetições do caracter que o precede.
padrão | casa com | não casa com |
---|---|---|
Jo*e |
Je, Joe, Jooe | Jose |
1*23 |
23, 123, 1123 | 1021 |
.* |
qualquer número de qualquer caracter |
A interrogação ?
representa zero ou uma repetição do caracter que o precede.
padrão | casa com | não casa com |
---|---|---|
Jo?e |
Je, Joe | Jooe |
1?23 |
23, 123 | 1123 1021 |
.? |
nenhum ou uma ocorrência de qualquer caracter |
O sinal de mais +
representa uma ou mais repetições do caracter que o precede.
padrão | casa com | não casa com |
---|---|---|
Jo+e |
Joe, Jooe | Je |
1+23 |
123, 1123 | 23 1021 |
.+ |
1 ou mais ocorrências de qualquer caracter |
As chaves {n}
indicam n repetições do caracter precedente.
{n,}
significa mínimo de n repetições do caracter precedente.
{n,m}
significa mínimo de n, máximo de m repetições do caracter precedente.
padrão | casa com | não casa com |
---|---|---|
A{3} |
AAA, GAAAA | AA AAB |
Ot{2}o |
Otto | Oto |
1{2}9{3} |
11999, A:11999 | 119, 11199 |
s{2,} |
passar, asssb | casa, sapo |
s{2,4} |
passar, asssb , sssss | casa, sapo |
.{5} |
5 repetições de qualquer caracter |
Os marcadores de posição ou âncoras ^ $ \b \B
permitem o controle da posição onde o padrão ocorre.
O circunflexo ^
indica que o padrão seguinte está no início da linha.
O cifrão $
indica que o padrão prévio está no final da linha.
A marca \b
indica início ou fim de uma palavra (uma sequência contínua de caracteres). \b
marca a passagem de um caracter alfanumérico ou sublinhado \w
para um não-caracter \W
.
A marca \B
, a negação de \b
, representa início ou fim de uma palavra envolta em um não-caracter \W
.
padrão | casa com | não casa com |
---|---|---|
^f |
filho | afazia |
^3{2} |
333-123 | 133-7654 |
s$ |
bois | essência |
m{3}$ |
booommm | mmmassa |
\bPedro |
Pedro –Pedro .Pedro | LPedro _Pedro |
Pedro\b |
Pedro Pedro– Pedro. | PedroL Pedro_ |
\BMaria |
LMaria _Maria 3Maria | Maria -Maria |
Maria\b |
Maria Maria– Maria. | MariaL Maria_ |
Observe que o sinal ^
serve como âncora, para marcar início da string, ou como sinal de negação.
A negação ocorre quando ^
é usado como primeiro sinal dentro de uma lista. Nesse caso ele nega todos os caracteres da lista.
padrão | casa com | não casa com |
---|---|---|
^[0-9].* |
1989, 5G (1) | G5 |
^[^0-9].* |
G7, I-99 (2) | 5G |
[0-9]^ |
0^, 1^ (3) | 55 |
^^.* |
uma linha iniciada por ^ | |
^$ |
uma linha vazia | |
.{5}$ |
casa 5 últimos caracteres de uma linha | |
^.{15,30}$ |
casa linhas com 15 até 30 caracteres |
(1): O padrão casa com textos que possuem um dígito no início.
(2): O padrão casa com textos que não se iniciam com um dígito.
(3): Qualquer dígito seguido do circunflexo literal ^
Classes de caracteres
Classes de caracteres são marcações que funcionam como “shortcuts”, representando um grupo de caracteres ou controles.
\s
representa um espaço simples.
\S
representa espaço negado (não é um espaço).
\d
representa qualquer dígito. O mesmo que [0-9].
\D
\d negado. Qualquer não dígito. O mesmo que [^0-9].
\w
caracter alfanumérico e sublinhado.
\W
\w negado. Qualquer sinal exceto caracter alfanumérico e sublinhado.
padrão | casa com | não casa com |
---|---|---|
\s |
casa da mãe Joana (espaços) | casa_da_mãe_Joana |
123\s456 |
123 456 99.123 456.90 | 123.456__123_456 |
\S |
casa | “ ” |
\d{3}/\d{2} |
123/56 987/78 | 22/3 aaa/bb |
\D+ |
já basta | 123 0000 |
\D{3}-\D{2} |
abc-de aAs-fg1 a2c-de | 123-00 |
\w+ |
atr3v1d0_b3sta phylos.net | — @@@ %%% |
\W+ |
--- @@@ %%% phylos.net | atr3v1d0_b3sta |
[\b] |
caracter de backspace | |
\c |
caracter de controle |
Para procurar por um dos metacaracteres como um literal dentro do texto usamos o escape \
.
padrão | casa com | não casa com |
---|---|---|
\\s |
No regex \s casa espaço, número \s987 | s ss “ ” |
R\$45 |
R$45 | R45 |
(U\$5|R\$25) |
U$5, R$25 | U$ 5 |
\\d\(\d{2}\) |
\d(69), \d(00) | \d(123), \d12 |
Agrupamentos
É possível encontrar um dos caracteres dentro de um conjunto de caracteres usando chaves []
. Essa notação permite a descrição de intervalos como [a-z]
, significando todas as letras minúsculas de a até z, ou [0-9]
, todos os dígitos.
padrão | casa com | não casa com |
---|---|---|
pr[ae]to |
prato, preto | prto, proto |
[a-e]rm |
arm, permanente, ermitão | frm, rm |
[5-7]00 |
500, 600, 700 | 800, 00 |
c[ep]* |
c, ce, cp, cep, ceep, ceepp | bep, ep |
</[bi]*> |
</b>, </i>, </>, </bi>, | /b, /i> |
</[bi]{1}> |
</b>, </i> | </>, </bi> |
Outros agrupamentos: alguns caracteres de controle permitem o agrupamento de texto e padrões.
(abc)
permite o agrupamento simples de caracteres (no caso ‘abc’).
[abc]
quaisquer dos caracteres (no caso abc).
[a-z]
: qualquer caracter no intervalo de a até z.
[^a-z]
: negação de [a-z]. Todos os caracteres exceto aqueles entre a e z.
[0-9]
: qualquer dígito entre 0 e 9.
[^0-9]
: negação de [0-9]. Tudo o que não é dígito.
a|b
: opcional, a ou b.
(padrao1|padrao1)
: busca por um ou outro padrão.
padrão | casa com | não casa com |
---|---|---|
(est) |
muito estudo, sem estado | Estimo, set |
[est]ato |
sato, tato | mato |
[f-h]ato |
fato, hato, gato | mato, rato, feto |
[^f-h]ato |
mato, rato, lato | fato, gato |
[^a-c]123 |
r123, M-123, s/123 | a123, b123 |
[1-5]-[6-9] |
1-6, 123-456, A5-6 | a1-b2, 6-1 |
[^1-5]6789 |
06789, 12345678900, R56789 | 16789 |
p(l|r)at |
platão, prata | pato, piato |
p(at|len)o |
pato, pleno | patleno, po, plo |
p(ratic|ublic|enal)idade |
praticidade, publicidade, penalidade | pcidade, pibcidade |
(s{2}|r{2})os |
carros passos nossos erros | casos, cappos, cassas |
[0-2][0-9]:[0-5][0-9] |
04:20, 12:50 | 34:30, 11:65 |
Uma observação importante: dentro de um agrupamento por colchetes ([]
) o ponto e todos os demais metacaracteres têm valor literal e não precisam ser “escapados”. A única exceção é o hífen, -
que serve para representar intervalos. Para inserir um hífen no padrão agrupado devemos colocá-lo como o último do grupo. Para usar o caracter ]
ele deve ser posto como o primeiro elemento para não ser confundido com o fechamento do grupo. Não há restrição sobre onde colocar o [
.
padrão | casa com | não casa com |
---|---|---|
12[:. ]45 |
12:45, 12.45, 12 45 | 1245, 12-45, 12/45 |
[$€¥]137 |
$137, €137, ¥137 | 137, R137 |
876[/_-]543 |
876/543, 876_543, 876-543 | 876 543, 876|543 |
doid[]oa] |
doid], doido, doida | doid[, doide, doid* |
doid[[oa] |
doid[, doido, doida | doid], doide, doid* |
9[1-5-][a-f] |
92b, 9-b | 95, 9-, 91g |
[*ab]\d |
*9, a3, b5 | 64 |
Observe que [*] = \*
.
Correspondência gananciosa ou preguiçosa
Por default as buscas quantificadas por * + {}
são gananciosas (greddy), o que significa que englobam a maior porção de texto casada com o padrão.
O padrão <.+>
significa ‘todos os caracteres entre os sinais < >
e casa com o maior texto possível iniciado por <
e finalizado por >
, mesmo que o caracter finalizador ocorra nesse intervalo casado. Portanto, se quisermos extrair o texto circundado pela tag div
devemos ser capazes de escrever um padrão que é interrompido no primeiro encontro do caracter finalizador >
. Essas são as chamadas buscas preguiçosas, o que é possível se obter com o acréscimo do sinal ? após o quantificador.
padrão | casa com | não casa com |
---|---|---|
<.+> |
<div class="classe">Todo o texto dentro da TAG</div> | texto sem tags |
<.+?> |
<div class="classe">Todo o texto dentro da TAG</div> | texto sem tags |
.*(\sR) |
primeiro R segundo R fim (1) | primeiro, segundo, fim |
.*?(\sR) |
primeiro R segundo R fim (2) | primeiro, segundo, fim |
\d+ |
1957 2021 258.1258 | abcd |
\d+? |
1957 2021 |
(1): .*(\sR)
significa “qualquer quantidade de caracteres seguido de espaço, depois um R”.
(2): A versão “prequiçosa” pára na primeira ocorrência de ” R”, depois casa um segundo grupo.
Observe que o padrão .*?
significa “zero ou qualquer número de qualquer caracter” e portando não casa com coisa alguma.
Resumindo:
Ganancioso | casa |
---|---|
ab* | abbbb |
ab+ | abbb |
ab? | ab |
ab{1,3} | abbb |
Preguiçoso | casa |
---|---|
ab*? | a |
ab+? | ab |
ab?? | a |
ab{1,3}? | ab |
Grupos
Caracteres dentro de chaves ()
são tratados como grupos e casados juntos. Todos os quantificadores e âncoras podem ser aplicadas aos grupos e podemos inclusive aninhá-los (usar um grupo dentro de outro).
padrão | casa com | não casa com |
---|---|---|
([a-z]+) |
casa com palavras de minúsculas | |
(bem|mal)\sfeito |
bem feito, mal feito | |
(bem|mal)?\sfeito |
bem feito, mal feito, feito | |
(in|con)?certo |
incerto, concerto, certo | |
(in|con)+certo |
incerto, concerto | certo |
(\.\d){2} |
.1.2, .4.5, .0.0 | 12, 1.2 |
(www\.)?phylos.net |
www.phylos.net, phylos.net | |
(hiper|hipo)(trofia|plasia) |
hipertrofia, hipotrofia, hiperplasia, hipoplasia | plasia, hipo |
((su|hi)per)?mercado |
supermercado, hipermercado, mercado | plasia, hipo |
Retrovisores
O grupos permitem o uso de retrovisores com a sintaxe (grupo)\1...9
. Esse uso de \1...9
(\ seguido de um dígito, 1 – 9) não tem relação com escape mas denota um grupo casado. Ele serve para a reutilização do trecho casado para uma nova busca no texto alvo.
Por ex.:
([a-z]+)
casa com palavras de uma ou mais letras minúsculas.
([a-z]+)-
casa com palavras de uma ou mais letras minúsculas seguidas de hífen.
([a-z]+)-\1
armazena o texto casado e o procura novamente, uma vez.
padrão | casa com | não casa com |
---|---|---|
([a-z]+)-\1 |
quero-quero, mau-mau, asdfg-asdfg | quero |
([a-z]+)-?\1 |
quero-quero, queroquero, bombom, bombomzeiro | bom |
in(co)lo(r) = sem \1\2 |
incolor = sem cor | |
\b([a-z]+)-?\1\b |
quero-quero, queroquero, bombom (1) | bombomzeiro |
\b(bo(na|to))\1\b |
bonabona, botoboto (2) | rbotoboto, bonabonas |
(rapida)(mente) conseguimos uma \2 \1 |
rapidamente conseguimos uma mente rapida (3) | |
(su)d(ão) do \1l n\2 |
sudão do sul não | |
(AA)(99)(hh) \3 \1 \2 |
AA99hh hh AA 99 (4) | AA99hhhhAA99 |
(AA)(99)(hh)\3\1\2 |
AA99hhhhAA99 (5) | AA99hh hh AA 99 |
(\d{2})(\d{3})(\d{2}) \1-\2-\3 |
1122233 11-222-33, 9988877 99-888-77 | 998877 99-88-77 |
((band)eira)nte \1 \2alheira |
bandeirante bandeira bandalheira (6) |
(1): \b
inicial e final significa que o padrão circundado é uma “palavra”.
(2): O padrão casado e repetido é bona ou boto no início e no fim da “palavra”.
(3): o 1º grupo é rapida
, o 2º é mente
.
(4): os grupos 1, 2 e 3 são capturados na ordem, e repetidos em outra ordem, separados com espaços.
(5): o mesmo que (4), exceto que os grupos são repetidos sem espaços.
(6): ilustrado na figura abaixo.
O retrovisor serve para procurar grupos repetidos. Os grupos são numerados de 1 até 9, contando-se da esquerda para a direita, sendo que o primeiro parêntese encontrado define a ordem do grupo.
Outras técnicas de grupos
Algumas técnicas mais sofisticadas foram implementadas nas expressões regulares, nem todas reconhecidas por todos os editores, IDEs e linguagens de programação. Para isso o metacaracter ainda não utilizado, (?..)
ganhou significado de operador em regex.
(?#texto de comentário)
(?:regex)
: grupo casado mas não armazenado nem incluído na contagem dos grupos.
padrão | casa com | não casa com |
---|---|---|
(?#nome)(pa)(pi) \2\1 |
papi pipa | papi papi |
(Jó) (?:Alto)- (Rui) \1 \2 |
Jó Alto Rui- Jó Rui | |
(?:Z)-(\d{2})-(\d{4}):\2:\1 |
Z-11-2222:2222:11, Z-45-9876:9876:45 | |
(?:\w)-(\d{3}) \1-\1 |
a-123 123-123, b-456 456-456 | a-123 123-121 |
padrao(?=regex)
: não é casado mas determina regex que deve existir após padrao.
(?<=regex)padrao
: não é casado mas determina regex que deve existir antes de padrao.
padrão | casa com | não casa com |
---|---|---|
casa (?=\d{2}) |
casa 23, casa 899 | casa dez, 852 casa |
Pedro(?=\sCa) |
Pedro Cabral, Pedro Camilo | Pedro Barata, Pedroca |
\d{4}(?=[A-Z]) |
, 1234A, 0987H, 6666GGG | 354W, G5432, 987G |
(?<=Albert) Einstein |
Albert Einstein | Alberto Einstein |
(?<=\d{3}) [a-r.]{5} |
123 roman, 987 coma. | 123 ruela |
(?!regex)
: não é casado mas determina regex que não deve existir após outro padrão.
(?<!regex)
: não é casado mas determina regex que não deve existir antes de outro padrão.
padrão | casa com | não casa com |
---|---|---|
casa (?!\d{2}) |
casa dez, casa verde | casa 12, casa 123 |
Pedro(?!\sCa) |
Pedro Bernardo, Pedro Bento, Pedroca | Pedro Cabral |
\d{4}(?![A-Z]) |
, 1234890, 0987-987 | 3354W, 5432H, 987G |
(?<!\d{2}) casa |
naquela casa, outra casa | 12 casa, 123 casa |
(?<!Pedro) Cabral |
José Cabral | Pedro Cabral |
(?<![A-Z])-\d{4} |
987-1234, 4-0987 | A-3354, H-5432 |
(?P<nome>regex)
: grupo casado e nomeado com nome
, ao invés de numerado com \1…\9.
Obs.: Essa é a sintaxe usado no Python. Ela pode variar em outros ambientes.
» data= '23 de junho de 2021' » regex= '^(?P\d{1,2})\sde\s(?P\w+)\sde\s(?P\d{4})' » matches= re.search(regex, data) » print('Dia: ', matches.group('dia')) » print('Mês: ', matches.group('mes')) » print('Ano: ', matches.group('ano')) ↳ Dia: 23 ↳ Mês: junho ↳ Ano: 2021
(?modificador)
: modificador é uma ou mais letras que ativam uma funcionalidade, sendo:
Modificador | Significado |
---|---|
i |
busca insensível ao caso |
m |
força o metacaracter . a casar com \n |
s |
obriga as âncoras ^ e $ a casarem com \n |
x |
permite a inclusão de espaços e comentários |
L |
força o uso da localização do sistema (só Python) |
u |
considera a tabela Unicode (só Python) |
padrão | casa com | não casa com |
---|---|---|
(?i)[a-z]* |
Pedro, aLLana | 654-654 |
(?i)[A-Z]* |
Pedro, aLLana | 654-654 |
(?i)\d+\.png |
1234.png, 1234.PNG | foto.png, 987000.jpg |
Precedência de metacaracteres
Quando vários metacaracteres aparecem juntos eles obedecem a uma ordem definida de precedência, definida pela ordem na tabela.
Ordem | Tipo | Exemplo | Significado |
---|---|---|---|
0 | () | (grupo) | grupos não quebrado |
1 | quantificador | abc+ | ab seguidos de c em qualquer quantidade |
2 | concatenar | abc | abc simples |
3 | | | ab|c | ab ou c |
3 | | | ab|c | ab ou c |
Alguns exemplos dessas regras de precedência:
padrão | casa com | significado |
---|---|---|
abc+ |
abc abcc abccc | “ab” seguido de 1 ou mais “c” |
abc |
abc abcc abccc | “abc”, juntos |
(abc) |
abc abcc abccc | “abc”, juntos, em grupo |
ab|c |
abc abc | “ab” ou “c” |
a(b|c) |
ab ac abc a abcc accc | “a” seguido de “b” ou “c” |
ab|cd* |
ab cd cddd abcdddddddd (1) | o mesmo que (ab)|(c(d*)) |
s/ n/|número \d* |
s/ n/ número 19000 | o mesmo que (s/ n/)|(número (\d*)) |
Para forçar uma união de caracteres em um grupo inquebrável usamos ()
.
(1): A concatenação em ab
tem prioridade sobre a alternância |
. d*
ocorre antes da concatenação com c
. Portanto ab|cd*
é o mesmo que (ab)|(c(d*))
.
Caracteres acentuados
Em português e outras línguas européias precisamos criar padrões que incluem caracteres com acentos. Uma alterniva é usar as classes POSIX listadas abaixo. Alternativamente podemos extender grupos de acordo com a tabela ASCII, o que é útil quando POSIX não está disponível.
POSIX | alternativa | significado |
---|---|---|
[[:lower:]] |
[a-zà-ü] |
minúsculas, acentuadas ou não |
[[:upper:]] |
[A-ZÀ-Ü] |
maiúsculas, acentuadas ou não |
[[:alpha:]] |
[A-Za-zÀ-ü] |
minúsculas e maiúsculas, acentuadas ou não |
[[:alnum:]] |
[A-Za-zÀ-ü0-9] |
todas as letras, acentuadas ou não, e dígitos |
padrão | casa com | significado |
---|---|---|
(ção)|(ções) |
noção noções | |
[à-ü] |
estúpido eqüinócio | |
[a-zà-ü]* |
retratação RETRATAÇÃO | |
[A-Za-zÀ-ü0-9]* |
retratação RETRATAÇÃO 2001 |
Classes POSIX
Nem todas as linguagens de programação aceitam as classes POSIX. Java e C dão suporte a POSIX e existem bibliotecas Python para o mesmo resultado.
Classe | Descrição |
---|---|
[:digit:] |
dígito, \d; equivalente a [0-9] |
^[:digit:] |
não dígito, \D; equivalente a [^0-9] |
[:alnum] |
letras e números ; equivalente a [A-Za-z0-9] |
[:space:] |
caracteres brancos ; equivalente a [ \t\n\r\f\v] |
^[:space:] |
não espaço: \S |
[:alpha:] |
letras; equivalente a [A-Za-z] |
[:lower:] |
minúsculas; equivalente a [a-z] |
[:upper:] |
maiúsculas; equivalente a [A-Z] |
[:xdigit:] |
números hexadecimais; equivalente a [0-9A-Fa-f] |
[:word:] |
\w qualquer caractere alfanumérico mais underscore (_); equivalente a [[:alnum:]_] |
^[:word:] |
\W, negação de \w |
[:blank:] |
espaço em branco e TAB; equivalente a [\t] |
[:punct:] |
pontuação; equivalente a [!”\#$%&'()*+,\-./:;<=>?@\[\\\]^_‘{|}~] |
Exemplos de validações com Regex
Alguns exemplos de validações com Expressões Regulares
Tipo de Validação | regex |
---|---|
Dígitos | ^\d+$ |
Letras | ^\w+$ |
Decimal | ^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$ ^[-+]?([0-9]*\,[0-9]+|[0-9]+)$ |
URL | ^((http)|(https)|(ftp)):\/\/([\- \w]+\.)+\w{2,3}(\/ [%\-\w]+(\.\w{2,})?)*$ |
^([\w\-]+\.)*[\w\- ]+@([\w\- ]+\.)+([\w\-]{2,3})$ |
|
Endereço IP | \b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b |
Tempo (24 horas) | ^([0|1|2]{1}\d):([0|1|2|3|4|5]{1} \d)$ |
Data (dd/mm/aaaa) | ^((0[1-9]|[12]\d)\/(0[1-9]|1[0-2])|30\/(0[13-9]|1[0-2])|31\/(0[13578]|1[02])) \/\d{4}$ |
Telefone | ^\(\d{3}\)-\d{4}-\d{4}$ |
Senha | ^\w{4,10}$ ^[a-zA-Z]\w{3,9}$ ^[a-zA-Z]\w*\d+\w*$ |
Bibliografia
- Marinho Jargas, Aurelio: Expressões Regulares, uma abordagem divertida, Novatec, São Paulo, 2012.
- Hunt, John: Advanced Guide to Python 3 Programming, Springer, Switzerland, 2019.
- Teste de Regex online: Untitled Pattern, acessado em junho de 2021.
- Programiz: Python, programming regex, acessado em junho de 2021.
- PYnative: Compile Regex Pattern using re.compile, acessado em junho de 2021.
- Regular-Expressions.info: Regex Tutorial, acessado em junho de 2021.