VBA - Iniciação às expressões regulares

Janeiro 2017



Introdução

Este tutorial não pretende explicar todas as sutilezas ligadas as expressões racionais. Nós iremos abordar aqui o preâmbulo à sua utilização Existem, na internet, outros tutoriais mais completos que este.

A finalidade aqui é aprender percorrer as cadeias (strings), e de ali encontrar sub cadeias graças à um motivo. Este motivo será indicado por um esquema, uma notação particular: a expressão racional.

Nós vamos, assim, descobrir as Expressões tracionais (mais comumente chamadas RegExp) por exemplo.

Referencia a marcar

No nosso editor VBA, no meio do menu ferramentas, vá em referencias.
Percorra as diferentes referencias e marque: Microsoft vbscript regular expressão 5.5"

Sintaxe et declaração

Nestes exemplos, os únicos termos que precisaremos são:

A declaração

Duas possibilidades se oferecem à nós:

As Objet

Provavelmente a mais simples a assimilar e guardar...

O código:

Dim reg As Object
Set reg = CreateObject("vbscript.regexp")

VBScript_RegExp_55.regexp

Esta notação é provavelmente a mais convencional.

Dim reg As VBScript_RegExp_55.regexp
Set reg = New VBScript_RegExp_55.regexp

As propriedades a conhecer para este tutorial

Pouco importa como você declara sua RegExp, as propriedade terão a mesma sintaxe.

Pattern

O Pattern representa o motivo que deve respeitar a sub cadeia. Ele é aquilo que nós buscamos encontrar na cadeia. Sua notação reveste um caractere de simplificação quando se utiliza as expressões regulares.
O código correspondente:

reg.Pattern = "AquiOMotivo"

Test

Como seu nome o indica, vai testar a cadeia e, se o Pattern (motivo) ali figura, vai reenviar True. Trata-se de um Boolean.

O código correspondente:

reg.Test(expressão_a_testar)


Isto sendo visto, nós podemos começar com os exemplos.

A cadeia começa por "A" Maiúsculo

O Pattern será então:
  • e, início de cadeia,
  • Tem um A

A notação deste motivo é: ^A simplesmente, que se colocará entre aspas.

Função Prem_Letra_A(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'O Pattern é o motivo que se busca 'início da cadeia: ^
'deve ser: A
reg.Pattern = "^A"
'o teste reenvia um Boolean (perfeito para uma função Boleana!!!)
Prem_Lettre_A = reg.test(expressão)
End Function


O procedimento de chamada para testar:

Sub Test_A()
'Nós vamos buscar se um String começa por "A" Maiúsculo
MsgBox Prem_Letra_A("então?")
MsgBox Prem_Letra_A("Ahhh")
MsgBox Prem_Letra_A("legal não?")
End Sub

Começa por a ou A

Aqui, nós vamos simplesmente identificar a primeira letra, sem respeitar a quebra.
A notação para a letra que não considera a quebra é: [aA]

Sub Test_a_ou_A()
'Nós vamos buscar se um String começa por "a" ou "A"
MsgBox Prem_Letra_a_ou_A("então ?")
MsgBox Prem_Letra_a_ou_A("Ahhh")
MsgBox Prem_Letra_a_ou_A("legal não?")
End Sub

Function Prem_Letra_a_ou_A(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'aqui a primeira letra: ^
'deve ser: a ou A => [aA]
reg.Pattern = "^[aA]"
Prem_Letra_a_ou_A = reg.test(expressão)
End Function

Começa por uma letra Maiúscula

Pouco importa a letra contanto que que seja maiúscula. A simplicidade das RegExp, e sobretudo de sua notação nos dá: [A-Z]

Sub Começa_por_Maiúscula()
MsgBox "então? Começa por uma maiúscula: " & Prem_Letra_Maiúscula("então?")
MsgBox "Ahhh  Começa por uma maiúscula:  " & Prem_Letra_Maiúscula("Ahhh")
MsgBox "Legal não?  Começa por uma maiúscula: " & Prem_Letra_Maiúscula("Legal não?")  
End Sub

Function Prem_Letra_Maiúscula(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'Aqui a primeira letra: ^
'deve ser uma letra maiúscula: [A-Z]
reg.Pattern = "^[A-Z]"
Prem_Letra_Maiúscula = reg.test(expressão)
End Function

Se termina por

Até então nós tínhamos visto «começa por», seja ^. A cadeia se termina por se nota: $, simplesmente.

Sub Fini_Par()
MsgBox "A frase: As RegExp é genial! se termina por genial: " & Fim_Da_Frase("As RegExp é genia!")
MsgBox "A frase: É genial as RegExp! se termina por genial: " & Fim_Da_Frase("É genial as RegExp!")
End Sub

Função Fim_Da_Frase(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'O fim da cadeia deve ser: genial!
'notação dofim da cadeia: $
reg.Pattern = "genial!$"
'note o $ se coloca no fim...
Fim_Da_Frase = reg.test(expressão)
End Function

Contem um número

A notação de "um número" vem da fonte. [0-9].
Se nós tínhamos desejado encontrar um numero entre 3 e 7 nós teríamos podido escrever:[3 7]

Sub Contem_um_número()
MsgBox "aze1rty Contem_um_número: " & A_Um_número("aze1rty")
MsgBox "azerty Contem_um_número: " & A_Um_ número ("azerty")
End Sub

Function A_Um_ número (expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'deve comportar um número de 0 a 9 qualquer ou (início, meio,fim da cadeia...)
reg.Pattern = "[0-9]"
'observação [0-9] se também se escreve: \d
    'reg.Pattern = "\d"
A_Um_Número = reg.test(expressão)
End Function

Contem um número com 3 dígitos

Nós iremos agora "quantificar" nossa RegExp. Para escreve o código que é preciso encontrar 3 ocorrências, convêm utilizar a chave: {}
Sub Contêm_Um_Número_A_três_Números()
MsgBox "aze1rty Contêm 3 números : " & Nb_A_Três_Número("aze1rty")
MsgBox "a1ze2rty3 Contêm 3 números : " & Nb_A_Três_Número("a1ze2rty3")
MsgBox "azer123ty Contêm 3 números : " & Nb_A_Três_Número("azer123ty")
End Sub

Function Nb_A_Três_Número(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'deve comportar 3 números de 0 à 9 em sequência 
'o número de ocorrência se anota {}
reg.Pattern = "\d{3}" 'equivalente de : reg.Pattern = "[0-9]{3}"
Nb_A_Três_Número = reg.test(expressão)
End Function

Contêm 3 números separados

Código

Sub Contêm_três_Números()
MsgBox "aze1rty Contêm 3 números separados : " & Três_Número("aze1rty")
MsgBox "a1ze2rty3 Contêm 3 números separados : " & Três_Número("a1ze2rty3")
MsgBox "azer123ty Contêm 3 números separados : " & Três_Número("azer123ty")
End Sub

Função Três_Número(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'deve comportar 3 números de 0 à 9 que não estão em sequência
'o número de ocorrência se nota {}
'o ponto (.) indica qualquer caracteres exceto o salto de linha.   
'o + indica que aquilo que o precede (aqui o ponto) deve ser representado uma ou uma infinidade de vezes 
reg.Pattern = "(.)+(\d{1})(.)+(\d{1})(.)+(\d{1})"
Três_Número = reg.test(expressão)
End Function

Variante

Sub Contêm_três_Números_Variante()
MsgBox "aze1rty Contêm 3 números separados : " & Três_Número_Simplificado ("aze1rty")
MsgBox "a1ze2rty3 Contêm 3 números separados : " & Três_Número_Simplificado ("a1ze2rty3")
MsgBox "azer123ty Contêm 3 números separados : " & Três_Número_Simplificado("azer123ty")
End Sub

Função Três_Número_Simplificado(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'Com o mesmo motive: (.)+(\d{1}) se repete três vezes:
reg.Pattern = "(.+\d{1}){3}"
Três_Número_Simplificado = reg.test(expressão)
End Function

Exemplo concreto

Aqui o objetivo será de definir se a cadeia é um encadeamento preciso de:
  • 1 : A palavra Vis no início da cadeia,
  • 2 : seguida de um espaço,
  • 3 : seguido de 1 a 3 letras,
  • 4 : seguidas de um espaço,
  • 5 : seguido da letra M,
  • 6 : seguida de 1 à 2 letras,
  • 7 : seguidas de um hífen,
  • 8 : seguido de 1 a 3 letras,
  • 9 : seguidas da palavra classe contornado de espaço E em maiúsculas
  • 10 : seguida de 1 a 2 letras,
  • 11 : seguidas de um ponto,
  • 12 : seguido de uma letra.

Importante:
Cada bloco do motivo e contornado por parênteses.

Notação:
1- => (^Vis) ^ representa o início da cadeia e Vis respeita a quebra (maiúscula, minúscula)
2- => ( )
3- => ([a-zA-Z]{1,3})
4- => ( ) --- Nota: poderia-se ter inserido....Mis para o exemplo
5- => (M)
6- => ([a-zA-Z]{1,2})
7- => ( -)
8- => ([a-zA-Z]{1,3})
9- => ( classe )
10- => ([a-zA-Z]{1,2})
11- => (\.)
12- => ([a-zA-Z]{1})

O que nos resulta o motivo abaixo :
"(^Vis)( )([a-zA-Z]{1,3})( )(M)([a-zA-Z]{1,2})(-)([a-zA-Z]{1,3})( classe )([a-zA-Z]{1,2})(.)([a-zA-Z]{1})"

O código:

Sub Main()
If VerifiqueMinhaCadeia("Vis xx Mxx-x classe xx.x") Then
    MsgBox "good"
Else
    MsgBox "pas glop"
End If
'falta o espaço antes do M:
If VerifiqueMinhaCadeia("Vis xxMxx-x classe xx.x") Then
    MsgBox "good"
Else
    MsgBox "pas glop"
End If
End Sub

Função VerifiqueMinhaCadeia(expressão As String) As Boolean
Dim reg As Object

Set reg = CreateObject("vbscript.regexp")
'Deve, certamente, ter mais simples, mas este é um exemplo para ser o mais claro possível. 
reg.Pattern = "(^Vis)( )([a-zA-Z]{1,3})( )(M)([a-zA-Z]{1,2})(-)([a-zA-Z]{1,3})( classe )([a-zA-Z]{1,2})(.)([a-zA-Z]{1})"
Verifiqueminhacadeia = reg.test(expressão)
End Function
End Sub

Conclusão & download

Os códigos dados neste tutorial estão todos juntos neste exemplo.

Agora você pode testar a sequência sem ter a exatidão na sub cadeia e poder se encontrar.

Encontre outros tutoriais sobre este assunto na página caféine. (em francês)

Veja também

Artigo original publicado por . Tradução feita por ninha25. Última modificação: 19 de agosto de 2014 às 06:41 por ninha25.
Este documento, intitulado 'VBA - Iniciação às expressões regulares ', está disponível sob a licença Creative Commons. Você pode copiar e/ou modificar o conteúdo desta página com base nas condições estipuladas pela licença. Não se esqueça de creditar o CCM (br.ccm.net) ao utilizar este artigo.