Buscando com a classe Regex

Conforme discutimos no artigo anterior, as Expressões regulares permitem que você defina padrões de pesquisa para trabalhar com strings. Para processar esse padrão de pesquisa, o .NET framework vem com uma classe muito versátil: A classe Regex. Neste artigo, vamos definir alguns padrões de pesquisa e usá-los com a classe Regex, mas tenha em mente que a sintaxe de expressões regulares pode ser bastante complicada e que este é um tutorial em C # e não um tutorial em Regex. Em vez disso, vou usar alguns padrões Regex simples para demonstrar como você trabalha com eles em C #. Se você quiser saber mais sobre a expressão regular, recomendo este tutorial sobre expressão regular .

O método IsMatch()

Neste primeiro exemplo, usarei um dos métodos mais básicos da classe Regex, chamado IsMatch. Ele simplesmente retorna verdadeiro ou falso, dependendo se há uma ou várias correspondências encontradas na string de teste:

string testString = "John Doe, 42 years";
Regex regex = new Regex("[0-9]+");
if (regex.IsMatch(testString))
    Console.WriteLine("String contains numbers!");
else
    Console.WriteLine("String does NOT contain numbers!");

Nós definimos uma string de teste e então criamos uma instância da classe Regex. Nós passamos a Expressão Regular real como uma string - neste caso, o regex especifica que estamos procurando por um número de qualquer tamanho. Em seguida, emitimos uma linha de texto, dependendo de a regex corresponder à nossa string de teste. Muito legal, mas na maioria dos casos, você está procurando fazer algo com a (s) partida (s) - para isso, temos a classe Match.

A classe de correspondência & amp; Método

Neste próximo exemplo, vamos capturar o número encontrado na string de teste e apresentá-lo ao usuário, em vez de apenas verificar se ele está lá:

string testString = "John Doe, 42 years";
Regex regex = new Regex("[0-9]+");
Match match = regex.Match(testString);
if (match.Success)
    Console.WriteLine("Number found: " + match.Value);

Usamos o mesmo regex e string de teste de antes. Eu chamo o método Match() , que retornará uma instância da classe Match - isso acontecerá se uma correspondência for encontrada ou não. Para garantir que uma correspondência tenha sido encontrada, eu verifico a propriedade Success . Quando tiver certeza de que uma correspondência foi encontrada, uso a propriedade Valor para recuperá-la.

A classe Match contém mais informações úteis do que apenas a string correspondente - por exemplo, você pode descobrir facilmente onde a correspondência foi encontrada, quanto tempo ela está e assim por diante:

string testString = "John Doe, 42 years";
Regex regex = new Regex("[0-9]+");
Match match = regex.Match(testString);
if (match.Success)
    Console.WriteLine("Match found at index " + match.Index + ". Length: " + match.Length);

As propriedades Índice e Comprimento são usadas aqui para exibir informações sobre o local e a duração da correspondência.

Grupos de Captura

Nos primeiros exemplos, acabamos de encontrar um único valor em nossa string de pesquisa, mas as Expressões Regulares podem, é claro, fazer muito mais do que isso! Por exemplo, podemos encontrar o nome e a idade em nossa string de teste, enquanto selecionamos as coisas irrelevantes, como o comando e o texto "anos". Fazer coisas como essas é muito fácil para o Regular Expressions, mas se você não estiver familiarizado com a sintaxe, pode parecer muito complicado, mas vamos tentar de qualquer maneira:

string testString = "John Doe, 42 years";
Regex regex = new Regex(@"^([^,]+),\s([0-9]+)");
Match match = regex.Match(testString);
if (match.Success)
    Console.WriteLine("Name: " + match.Groups[1].Value + ". Age: " + match.Groups[2].Value);

Eu modifiquei o regex para que ele procure por algo que NÃO seja uma vírgula - esse valor é colocado no primeiro grupo de captura, graças aos parênteses ao redor. Em seguida, ele procura a vírgula de separação e, depois disso, um número, que é colocado no segundo grupo de captura (novamente, graças aos parênteses adjacentes). Na última linha, uso a propriedade Groups para acessar os grupos correspondidos. Eu uso o índice 1 para o nome e 2 para a idade, uma vez que segue a ordem em que os grupos de correspondências foram definidos na cadeia regex (o índice 0 contém a correspondência inteira).

Grupos de captura nomeados

Assim que o regex se torna mais avançado/mais longo do que o que acabamos de usar, grupos de captura numerados podem se tornar impossíveis de gerenciar, porque você tem que lembrar constantemente a ordem e o índice deles. Felizmente para nós, o Expressões Regulares e o .NET framework suportam grupos de captura nomeados, o que permitirá que você dê a cada grupo um nome no regex e, em seguida, faça referência a ele na propriedade Groups. Veja este exemplo reescrito, em que usamos grupos nomeados em vez de numerados:

string testString = "John Doe, 42 years";
Regex regex = new Regex(@"^(?<name>[^,]+),\s(?<age>[0-9]+)");
Match match = regex.Match(testString);
if (match.Success)
    Console.WriteLine("Name: " + match.Groups["name"].Value + ". Age: " + match.Groups["age"].Value);

Ele funciona exatamente como antes, mas agora você pode usar nomes lógicos para pesquisar os valores correspondentes, em vez de precisar lembrar do índice correto. Isso pode não ser uma grande diferença em nosso exemplo simples, mas, como mencionado, você definitivamente apreciará quando suas Expressões Regulares aumentarem em complexidade e duração.

A classe MatchCollection

A classe Match é o caminho a percorrer se você quiser trabalhar apenas com uma única correspondência (lembre-se de que uma correspondência pode conter vários valores, como vimos nos exemplos anteriores), mas às vezes você quer trabalhar com várias correspondências de uma só vez. Para isso, temos o método Matches() que retornará uma classe MatchCollection. Ele conterá todos os valores correspondentes, na ordem em que foram encontrados. Vamos dar uma olhada em como isso pode ser usado:

string testString = "123-456-789-0";
Regex regex = new Regex(@"([0-9]+)");
MatchCollection matchCollection = regex.Matches(testString);
foreach (Match match in matchCollection)
    Console.WriteLine("Number found at index " + match.Index + ": " + match.Value);

Eu mudei o regex e a string de teste, em comparação com os exemplos anteriores. Agora temos uma string de teste que contém vários números e uma regex que especificamente procura por strings consistindo em um ou mais números. Usamos o método Matches() para obter uma MatchCollection da nossa regex, que contém as correspondências encontradas na string. Neste caso, há quatro correspondências, as quais são enviadas uma após a outra com um loop foreach . O resultado será algo parecido com isto:

Number found at index 0: 123
Number found at index 4: 456
Number found at index 8: 789
Number found at index 12: 0

Se nenhuma correspondência for encontrada, uma MatchCollection vazia teria sido retornada.

Resumo

Com a ajuda da classe Regex, juntamente com as classes Match e MatchCollection, podemos facilmente fazer correspondência de strings muito avançada. A sintaxe da Expressão Regular pode parecer muito complexa, mas uma vez que você a aprende, você terá uma ferramenta muito forte. Mesmo que você não queira investir tempo na aprendizagem da sintaxe regex, muitas vezes você pode encontrar expressões para necessidades específicas, criadas por outros programadores, com uma simples pesquisa no Google. Assim que você tiver escrito ou emprestado a string regex, poderá usá-la para seu próprio propósito com as técnicas e classes demonstradas neste artigo.

Mas pesquisar é apenas uma parte da diversão - você também pode fazer algumas operações muito interessantes de pesquisa/substituição com Expressões Regulares. Vamos ver isso em um dos próximos artigos.