Expressões regulares, também conhecidas como expressões de padrão, são um padrão de texto usado para pesquisar, substituir e controlar texto. Elas incluem letras de a a z, além de alguns caracteres especiais. O uso de expressões regulares é muito amplo, inicialmente popularizado pelo Unix e amplamente utilizado em Scala, PHP, C#, Java, C++, Objective-C, Perl, Swift, VBScript, Javascript, Ruby e Python, entre outros. Aprender expressões regulares é, na verdade, aprender uma forma de raciocínio lógico muito flexível, permitindo o controle de strings de forma rápida e simples.

Caractere Regex	Descrição
\	Marca o próximo caractere como um caractere especial, um caractere literal, uma referência de retrocesso, ou um caráter de escape octal. Por exemplo, “`n`" corresponde ao caractere"`n`" e "`\n`" corresponde a uma nova linha. A string "`\\`" corresponde a "`\`" e "`\(`" corresponde a "`(`".
^	Corresponde ao início da string de entrada. Se a propriedade Multiline do objeto RegExp for definida, ^ também corresponde à nova linha "“`\n`" ou à posição após "`\r`".
$	Corresponde ao final da string de entrada. Se a propriedade Multiline do objeto RegExp for definida, $ também corresponde à nova linha "“`\n`" ou à posição antes de "`\r`".
*	Corresponde à expressão anterior zero ou mais vezes. Por exemplo, zo* pode corresponder a "“`z`" e "`zoo`" . * equivale a {0,}.
+	Corresponde à expressão anterior uma ou mais vezes. Por exemplo, “`zo+`" pode corresponder a "`zo`" e "`zoo`", mas não a "`z`". + equivale a {1,}.
?	Corresponde à expressão anterior zero ou uma vez. Por exemplo, “`do(es)?`" pode corresponder a "`does`" ou ao "`do`" dentro de "`does`". ? equivale a {0,1}.
{n}	n é um número inteiro não negativo. Corresponde a exatamente n vezes. Por exemplo, “`o{2}`" não corresponderá ao "`o`" dentro de "Bob", mas corresponderá aos dois "o" em "food".
{n,}	n é um número inteiro não negativo. Corresponde a pelo menos n vezes. Por exemplo, “`o{2,}`" não corresponderá ao "`o`" em "Bob", mas corresponderá a todos os "o" em "foooood". "`o{1,}`" equivale a "`o+`" e "`o{0,}`" equivale a "`o*`".
{n,m}	m e n são inteiros não negativos, onde n<=m. Corresponde pelo menos n vezes e no máximo m vezes. Por exemplo, “`o{1,3}`" irá corresponder aos três primeiros "o" em "fooooood". "`o{0,1}`" equivale a "`o?`". Observe que não deve haver espaço entre a vírgula e os dois números.
?	Quando este caractere segue qualquer um dos outros quantificadores (*, +, ?, {n}, {n,}, {n,m}), o padrão correspondente é não ganancioso. O modo não ganancioso tenta corresponder o menor número de caracteres possíveis, enquanto o modo ganancioso padrão tenta corresponder ao maior número de caracteres. Por exemplo, para a string “`oooo`", "`o+?`" irá corresponder a um único "`o`", enquanto "`o+`" irá corresponder a todos os "`o`".
.	Corresponde a qualquer caractere único, exceto "“`\n`". Para corresponder a qualquer caractere, incluindo "<`\n`", use um padrão como "`(.\|\n)`".
(padrão)	Corresponde ao padrão e captura essa correspondência. A correspondência capturada pode ser acessada na coleção de Matches, usando a coleção SubMatches no VBScript e a propriedade $0…$9 no JScript. Para corresponder ao caractere de parêntese, use "“`$`" ou "`$`".
(?:padrão)	Corresponde ao padrão, mas não captura o resultado da correspondência, ou seja, é uma correspondência não capturada, não armazenada para uso posterior. Isso é útil ao usar o caractere de alternância "“`(\|)`" para combinar partes de um padrão. Por exemplo, "`industr(?:y\|ies)`" é uma expressão mais concisa do que "`industry\|industries`".
(?=padrão)	Verificação positiva antecipada, que corresponde ao início da string buscada onde o padrão é encontrado. Esta é uma correspondência não capturada, ou seja, a correspondência não precisa ser armazenada para uso posterior. Por exemplo, “`Windows(?=95\|98\|NT\|2000)`" corresponde a "`Windows`" em "`Windows2000`", mas não corresponde a "`Windows`" em "`Windows3.1`". A verificação antecipada não consome caracteres, ou seja, após uma correspondência, a próxima busca de correspondência começa imediatamente após a última correspondência, e não após os caracteres que incluíam a verificação.
(?!padrão)	Verificação negativa antecipada, que corresponde ao início da string de busca onde o padrão não é encontrado. Esta é uma correspondência não capturada, ou seja, a correspondência não precisa ser armazenada para uso posterior. Por exemplo, “`Windows(?!95\|98\|NT\|2000)`" corresponde a "`Windows`" em "`Windows3.1`", mas não a "`Windows`" em "`Windows2000`". A verificação antecipada não consome caracteres, ou seja, após uma correspondência, a próxima busca de correspondência começa imediatamente após a última correspondência, e não após os caracteres que incluíam a verificação.
(?<=padrão)	Verificação positiva retroativa, semelhante à verificação positiva antecipada, mas na direção oposta. Por exemplo, “`(?<=95\|98\|NT\|2000)Windows`" pode corresponder ao "`Windows`" em "`2000Windows`", mas não a "`Windows`" em "`3.1Windows`".
(?<!padrão)	Verificação negativa retroativa, semelhante à verificação negativa antecipada, mas na direção oposta. Por exemplo, “`(?<!95\|98\|NT\|2000)Windows`" pode corresponder ao "`Windows`" em "`3.1Windows`", mas não ao "`Windows`" em "`2000Windows`".
x\|y	Corresponde a x ou y. Por exemplo, “`z\|food`" pode corresponder a "`z`" ou "`food`". "`(z\|f)ood`" corresponde a "`zood`" ou "`food`".
[xyz]	Conjunto de caracteres. Corresponde a qualquer um dos caracteres contidos dentro dos colchetes. Por exemplo, “`[abc]`" pode corresponder ao "`a`" em "plain".
[^xyz]	Conjunto de caracteres negativo. Corresponde a qualquer caractere que não esteja entre os colchetes. Por exemplo, “`[^abc]`" pode corresponder ao "`p`" em "plain".
[a-z]	Intervalo de caracteres. Corresponde a qualquer caractere dentro do intervalo especificado. Por exemplo, “`[a-z]`" pode corresponder a qualquer letra minúscula de "`a`" a "`z`".
[^a-z]	Intervalo de caracteres negativo. Corresponde a qualquer caractere que não esteja dentro do intervalo especificado. Por exemplo, “`[^a-z]`" pode corresponder a qualquer caractere que não esteja no intervalo de "`a`" a "`z`".
\b	Corresponde a uma fronteira de palavra, que é a posição entre uma palavra e um espaço. Por exemplo, “`er\b`" pode corresponder ao "`er`" em "`never`", mas não ao "`er`" em "`verb`".
\B	Corresponde a uma não fronteira de palavra. “`er\B`" pode corresponder ao "`er`" em "`verb`", mas não ao "`er`" em "`never`".
\cx	Corresponde a um caractere de controle especificado por x. Por exemplo, \cM corresponde a um Control-M ou caractere de nova linha. O valor de x deve ser uma letra de A-Z ou a-z. Caso contrário, c é tratado como um caractere literal "`c`".
\d	Corresponde a um caractere numérico. Equivale a [0-9].
\D	Corresponde a um caractere não numérico. Equivale a [^0-9].
\f	Corresponde a um caractere de quebra de página. Equivale a \x0c e \cL.
\n	Corresponde a um caractere de nova linha. Equivale a \x0a e \cJ.
\r	Corresponde a um caractere de retorno. Equivale a \x0d e \cM.
\s	Corresponde a qualquer caractere em branco, incluindo espaço, tabulação, quebra de página, etc. Equivale a [ \f\n\r\t\v].
\S	Corresponde a qualquer caractere não em branco. Equivale a [^ \f\n\r\t\v].
\t	Corresponde a um caractere de tabulação. Equivale a \x09 e \cI.
\v	Corresponde a um caractere de tabulação vertical. Equivale a \x0b e \cK.
\w	Corresponde a qualquer caractere alfanumérico, incluindo o caractere de sublinhado. Equivale a "`[A-Za-z0-9_]`".
\W	Corresponde a qualquer caractere não alfanumérico. Equivale a "`[^A-Za-z0-9_]`".
\xn	Corresponde a n, onde n é um valor de escape hexadecimal. Os valores de escape hexadecimal devem ter exatamente dois dígitos. Por exemplo, “`\x41`" corresponde a "`A`". "`\x041`" é equivalente a "`\x04&1`". Os códigos ASCII podem ser usados nas expressões regulares.
\num	Corresponde a num, onde num é um inteiro positivo. Usado para referenciar correspondências capturadas. Por exemplo, “`(.)\1`" corresponde a dois caracteres iguais consecutivos.
\n	Identifica um valor de escape octal ou uma referência a retrocesso. Se houver pelo menos n subexpressões capturadas antes de \n, então n é uma referência a retrocesso. Caso contrário, se n for um número octal (0-7), então n é um valor de escape octal.
\nm	Identifica um valor de escape octal ou uma referência a retrocesso. Se houver pelo menos nm subexpressões capturadas antes de \nm, isso pode ser uma referência a retrocesso. Se houver pelo menos n capturas antes, n é uma referência a retrocesso seguida de um literal m. Se nenhuma das condições anteriores for satisfeita, se n e m forem ambos dígitos octais (0-7), então \nm corresponderá ao valor de escape octal nm.
\nml	Se n for um número octal (0-3), e m e l forem ambos números octais (0-7), então corresponderá ao valor de escape octal nml.
\un	Corresponde a n, onde n é um caractere Unicode representado por quatro dígitos hexadecimais. Por exemplo, \u00A9 corresponde ao símbolo de copyright (©).

Expressões Regulares Comuns

Nome de Usuário	/^[a-z0-9_-]{3,16}$/
Senha	/^[a-z0-9_-]{6,18}$/
Senha 2	(?=^.{8,}$)(?=.\d)(?=.\W+)(?=.[A-Z])(?=.[a-z])(?!.\n).$ (deve incluir número/caráteres maiúsculos/minúsculos/símbolos, todos obrigatórios e com pelo menos 8 dígitos)
Valor Hexadecimal	/^#?([a-f0-9]{6}\|[a-f0-9]{3})$/
E-mail	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/ ou \w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)
URL	/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/ ou [a-zA-z]+://[^\s]*
Endereço IP	/((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)/ /^(?:(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)$/ ou ((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)
Tags HTML	/^<([a-z]+)([^<]+)(?:>(.)<\/\1>\|\s+\/>)$/ ou <(.)(.)>.<\/\1>\|<(.) \/>
Remover Código\\Comentários	(?<!http:\|\S)//.*$
Correspondência de Caractere de Dois Bytes (incluindo caracteres chineses)	[^\x00-\xff]
Caracteres Chineses	[\u4e00-\u9fa5]
Intervalo de Caracteres Chineses em Códigos Unicode	/^[\u2E80-\u9FFF]+$/
Caracteres Chineses e Pontuação Completa	[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Data (Ano-Mês-Dia)	(\d{4}\|\d{2})-((0?([1-9]))\|(1[1\|2]))-((0?[1-9])\|([12]([1-9]))\|(3[0\|1]))
Data (Mês/Dia/Ano)	((0?[1-9]{1})\|(1[1\|2]))/(0?[1-9]\|([12][1-9])\|(3[0\|1]))/(\d{4}\|\d{2})
Hora (Hora:Minuto, 24-Horas)	((1\|0?)[0-9]\|2[0-3]):([0-5][0-9])
Telefone Fixo da China Continental	(\d{4}-\|\d{3}-)?(\d{8}\|\d{7})
Número de Celular da China Continental	1\d{10}
CEP da China Continental	[1-9]\d{5}
Número de Identidade da China Continental (15 ou 18 Dígitos)	\d{15}(\d\d[0-9xX])?
Número Não Negativo (Número Positivo ou Zero)	\d+
Número Positivo	[0-9][1-9][0-9]
Número Negativo	-[0-9][1-9][0-9]
Número Inteiro	-?\d+
Número Decimal	(-?\d+)(\.\d+)?
Linha em Branco	\n\s\r ou \n\n(editplus) ou ^[\s\S ]\n
Número QQ	[1-9]\d{4,}
Palavras que NÃO contêm abc	\b((?!abc)\w)+\b
Correspondência de Caractere em Branco no Início e no Fim	^\s\|\s$
Editar Comum	Abaixo estão algumas substituições para caracteres especiais em chinês (editplus) ^[0-9].\n ^[^第].\n ^[习题].\n ^[\s\S ]\n ^[0-9]\. ^[\s\S ]\n <p[^<>]> href="javascript:if$confirm\('(.?)'$\)window\.location='(.?)'" <span style=".[^"]rgb$255,255,255$">.[^<>]</span> <DIV class=xs0>[\s\S]?</DIV>

Referência Rápida de Sintaxe de Expressões Regulares - Dicas e Sintaxes Comuns

As expressões regulares são uma poderosa ferramenta de processamento de texto. Esta página oferece umareferência rápida de sintaxe de expressões regulares, ajudando você a entender rapidamente a sintaxe básica, modificadores, subexpressões, modos gananciosos e não gananciosos, entre outros.

Sintaxe Básica de Expressões Regulares

As expressões regulares são usadas para descrever padrões de string. A sintaxe básica comum inclui:

Ponto (.) : Corresponde a qualquer caractere único (exceto quebra de linha).
Conjunto de Caracteres ([ ]) : Corresponde a qualquer caractere contido entre os colchetes. Por exemplo: [a-z] corresponde a todas as letras minúsculas.
Exclusão de Conjunto de Caracteres ([^ ]) : Corresponde a qualquer caractere que não esteja dentro dos colchetes. Por exemplo: [^0-9] corresponde a caracteres não numéricos.
Quantificadores (*, +, ?) : Indicam quantas vezes a correspondência deve ocorrer. Por exemplo: a* corresponde a zero ou mais "a".
Âncoras (^, $) : ^ indica o início da string, $ indica o fim da string.

Modificadores Comuns de Expressão Regular

Os modificadores de expressões regulares alteram as regras de correspondência. Os modificadores comuns incluem:

g (correspondência global): Correspondência de todas as instâncias que atendem aos critérios, não apenas à primeira.
i (ignorar maiúsculas e minúsculas): Ignora as diferenças entre maiúsculas e minúsculas na correspondência.
m (correspondência em várias linhas): Faz com que ^ e $ correspondam ao início e fim de cada linha.

Modos Gananciosos e Não Gananciosos

Em expressões regulares, os quantificadores são gananciosos por padrão, tentando corresponder ao maior número possível de caracteres. O modo não ganancioso pode ser acionado adicionando um ? após o quantificador, como mostrado:

Modo Ganancioso: a.*b corresponderá a todos os caracteres entre a e b (incluindo muitos b).
Modo Não Ganancioso: a.*?b corresponderá ao menor número de caracteres entre a e b.

Subexpressões e Agrupamento

Subexpressões em expressões regulares usam parênteses ( ( ) ) para defini-las e são frequentemente usadas para capturar partes correspondentes. O agrupamento é realizado usando o símbolo “|”. Por exemplo:

Subexpressão: (abc) corresponde e captura a string “abc”.
Agrupamento: (abc|def) corresponde a “abc” ou “def”.

Consulta Rápida de Expressões Regulares

A seguir estão consultas rápidas para expressões regulares comuns:

Função	Expressão Regular
Corresponde a Números	\d
Corresponde a Não Números	\D
Corresponde a Letras	[a-zA-Z]
Corresponde a Qualquer Caractere	.
Corresponde a Caracteres em Branco	\s

Aplicações de Expressões Regulares

As expressões regulares são amplamente utilizadas nas seguintes situações:

Validação de Dados: por exemplo, validação de e-mails, números de telefone, formatos de endereços IP, etc.
Busca de Texto: localizar strings correspondentes dentro do texto.
Limpeza de Dados: usar expressões regulares para remover ou substituir caracteres ou padrões específicos.
Análise de Logs: extrair informações de arquivos de log e filtrar linhas específicas.

Dicas para Aprender Expressões Regulares

Comece pelo Básico: domine primeiro os símbolos e sintaxes fundamentais antes de passar para expressões regulares mais complexas.
Pratique Bastante: aprofunde sua compreensão por meio de aplicações práticas.
Utilize Ferramentas de Expressões Regulares: aproveite ferramentas de teste de expressões regulares para validar e depurar suas expressões.

Use nossareferência rápida de sintaxe de expressões regulares agora e aumente sua eficiência ao escrever expressões regulares, melhorando suas habilidades de tratamento de texto!