As expressões regulares (ou Regex) são padrões utilizados para identificar, validar, buscar e manipular textos de forma eficiente. Em outras palavras, elas são uma maneira de “descrever” o que você está procurando em um texto. Sejam validações de formulários, extração de dados ou ajustes em strings, o uso de Regex pode simplificar bastante essas tarefas.
No C#, você pode usar o namespace “System.Text.RegularExpressions” para trabalhar com Regex de maneira simples e prática.
Como funcionam as expressões regulares?
Uma expressão regular combina caracteres especiais para formar padrões. Esses padrões podem ser usados para dizer ao programa exatamente o que procurar. Vamos explorar alguns exemplos para entender melhor.
Verificando o início de uma string
O metacaractere “^” é usado para verificar se uma string começa com determinados tipos de caracteres.
Para aceitar letras minúsculas, você pode usar “^[a-z]”. Essa expressão indica que o texto deve começar com uma letra minúscula de “a” a “z”. Para aceitar letras maiusculas, minúsculas ou números, use “^[a-zA-Z0-9]”. Essa expressão define que o texto pode iniciar com uma letra (maiuscula ou minúscula) ou um número.
Em muitos casos, como na validação de senhas, você pode querer garantir que a string comece com uma letra maiuscula. Para isso, utiliza-se a expressão:
string senha = "Segura123";
bool comecaComMaiuscula = Regex.IsMatch(senha, "^[A-Z]");
Console.WriteLine(comecaComMaiuscula ? "Senha válida" : "Senha inválida");
Se a senha for “Segura123”, a saída será “Senha válida”.
Verificando o final de uma string com $
Já o símbolo “$” é usado para verificar se uma string termina com algo específico. Isso é útil, por exemplo, para validar extensões de arquivos.
Com exemplo, imagine que você deseja garantir que o nome de um arquivo termina com a extensão “.txt”, pode usar a expressão “.txt$”
string arquivo = "documento.txt";
bool ehTxt = Regex.IsMatch(arquivo, ".txt$");
Console.WriteLine(ehTxt ? "Arquivo de texto" : "Outro tipo de arquivo");
Se o arquivo for “documento.txt”, a saída será “Arquivo de texto”.
Combinando esses elementos, é possível criar padrões mais complexos para resolver problemas comuns de maneira eficiente.
Classes principais em System.Text.RegularExpressions
Como vimos nos exemplos acima, a classe “Regex” é a utilizada para trabalhar com expressões regulares no C#. Ela oferece métodos para correspondência, validação e substituições em strings.
IsMatch
O método “IsMatch” responde com um “true” ou “false” para saber se um padrão é encontrado no texto.
string input = "ABC123";
string padrao = @"^ABC";
if (Regex.IsMatch(input, padrao))
{
Console.WriteLine($"'{input}' começa com 'ABC'.");
}
else
{
Console.WriteLine($"'{input}' não começa com 'ABC'.");
}
O padrão “^ABC” é composto por duas partes:
- ^: Indica que a correspondência deve ocorrer no início da string.
- ABC: Representa o texto literal “ABC”.
Este regex verifica se a string começa exatamente com os caracteres “ABC”.
Match
Com o método “Match”, você pode encontrar a primeira correspondência de um padrão no texto.
Match match = Regex.Match("Meu telefone é 123-456-7890", @"\d{3}-\d{3}-\d{4}");
if (match.Success)
{
Console.WriteLine(match.Value);
}
O padrão “\d{3}-\d{3}-\d{4}” é usado para encontrar um número de telefone no formato “123-456-7890”. Ele é composto por:
- \d{3}: Representa exatamente 3 dígitos (o \d significa “qualquer dígito” e {3} especifica que queremos 3 dígitos).
- -: Um hífen literal que deve estar entre os grupos de números.
- \d{3}: Outro grupo de 3 dígitos.
- -: Outro hífen.
- \d{4}: Um grupo de 4 dígitos.
Este regex encontra a primeira sequência que corresponde a esse formato. No exemplo, o número “123-456-7890” é encontrado e exibido.
Observação: ao colocar o “@” antes de uma string, você pode usar barras invertidas (\) sem precisar duplicá-las. Por exemplo, ao invés de escrever “\\d” para representar um dígito, você pode usar “\d”, tornando o código mais simples e fácil de ler.
Matches
O método “Matches” retorna todas as correspondências encontradas em uma string.
MatchCollection matches = Regex.Matches("123, 456, 789", @"\d+");
foreach (Match m in matches)
{
Console.WriteLine(m.Value);
}
O padrão “\d+” é usado para encontrar qualquer sequência de um ou mais dígitos:
- \d: Significa “qualquer dígito”.
- +: Indica “um ou mais” da expressão que o precede.
Esta regex encontra todas as sequências numéricas na string. No exemplo, ele encontra “123”, “456”, e “789” separadamente, porque cada grupo de números é delimitado por uma vírgula e espaço.
Replace: Substituir partes do texto
Com o método Replace, você pode substituir partes de uma string com base em um padrão.
string result = Regex.Replace("2024-12-22", "-", "/");
Console.WriteLine(result);
O método “Regex.Replace” substitui todas as ocorrências do hífen (-) pelo caractere barra (/).
No exemplo, a string “2024-12-22” é transformada em “2024/12/22” ao substituir cada hífen por uma barra.
Aplicações práticas no dia a dia
Agora que você conhece os fundamentos, vamos explorar um exemplo prático de expressões regulares que pode ser usado em situações reais. Para isso, vamos criar um regex de validação de e-mails que será retornado se o e-mail é válido ou não.
string email = "nextwaveeducation@mail.com";
string padraoEmail = @"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$";
bool emailValido = Regex.IsMatch(email, padraoEmail);
Console.WriteLine(emailValido ? "Email válido" : "Email inválido");
O “^[a-zA-Z0-9._%+-]+” verifica se o texto começa com um ou mais caracteres que podem ser letras maiúsculas (A-Z), letras minúsculas (a-z), números (0-9), ponto (.), sublinhado (_), percentual (%), mais (+) ou hífen (-).
Após isso, é adicionado o símbolo “@”, que é obrigatório e indica o início do domínio. Essa parte exige a presença de letras, números, pontos e hífens logo após o símbolo “@”. Isso é representado pelo trecho “[a-zA-Z0-9.-]+”.
A terceira parte informa que é necessário um ponto (\.), que representa um ponto literal. Por fim, a última parte, “[a-zA-Z]{2,}$”, exige que o e-mail termine com pelo menos duas letras, indicando a extensão do domínio, como “.com” ou “.org”’. O “$” garante que o texto termina exatamente nesta condição.
Construção e teste de Regex
Caso você queira praticar ou testar expressões regulares, existem alguns sites que podem ser extremamente úteis para auxiliar nesse processo.
Regex101 : Uma plataforma popular para praticar expressões regulares de forma interativa. Ela destaca cada parte do padrão com explicações detalhadas.
RegexStorm : Ideal para quem desenvolve em .NET, esta ferramenta permite testar expressões regulares diretamente no contexto dessa plataforma.
Boas práticas com Regex
Para usar expressões regulares de forma eficiente e sustentável, é importante seguir algumas boas práticas:
Comente Regex complexas: Se for inevitável criar padrões mais complicados, adicione comentários no código para explicar cada parte da expressão. Isso torna a manutenção mais simples e ajuda a evitar erros em atualizações futuras.
Teste para performance: Em textos grandes, padrões mal otimizados podem impactar significativamente a performance da aplicação. Certifique-se de que seu Regex é eficiente, especialmente ao processar grandes volumes de dados ou executar validações frequentemente.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
Expressões regulares podem ser verdadeiras aliadas no dia a dia de desenvolvimento, auxiliando em diversas validações e manipulações de texto nos seus projetos. Seja para verificar a validade de um email, extrair números de telefone em um texto ou formatar entradas de dados, o uso de Regex em C# proporciona uma abordagem eficiente e precisa. Ao dominar essa ferramenta, você estará melhor equipado para lidar com desafios comuns de manipulação de strings, otimizando seu código e tornando-o mais robusto e funcional.