VBA - expressões regulares

Este tutorial tem como objetivo explicar todas as complexidades relacionadas ao uso de expressões regulares. Você aprenderá a navegar pelas strings para encontrar substrings usando expressões regulares (comumente chamadas de RegExp ).

Pré-requisitos

No editor do VBA.

Vá para o menu Ferramentas> Referências.
Navegue pelas várias referências e verifique a seguinte opção "Microsoft VBScript Regular Expression 5.5".

Sintaxe e declaração

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

A declaração

Duas opções estão disponíveis:

Como objeto

 Dim reg como objeto definido reg = CreateObject ("vbscript.regexp")

VBScript_RegExp_55.regexp

 Dim reg As VBScript_RegExp_55.regexp Definir reg = Novo VBScript_RegExp_55.regexp

As propriedades

Não importa como você declarou o RegExp, as propriedades terão a mesma sintaxe.

O padrão

O padrão deve estar de acordo com a substring. Ele permite que você navegue pela string.

 reg.Pattern = "IciLeMotif"

Teste

Vamos testar a string, se o padrão for encontrado, ele retorna o seguinte valor booleano: True.

 reg.Test = "IciLeMotif"

A string começa com A (maiúscula)

O padrão seria:

no começo da string
existe um A

A notação deste padrão é: ^ A

 Função Prem_Lettre_A (expressão As String) Como Booleana Dim reg Como Objeto Definido reg = CreateObject ("vbscript.regexp") 'Le Pattern é o motivo que pesquisa em début de chaîne: ^' doit être: A reg.Pattern = "^ A" 'le test renvoie un Booleano (parfait pour notre fonction Booléenne !!!) Prem_Lettre_A = reg.test (expressão) End Function

Para chamar a função:

 Sub Test_A () 'Nous allons chercher si un String começa com par "A" Majuscule MsgBox Prem_Lettre_A ("alors?") MsgBox Prem_Lettre_A ("Ahhh") MsgBox Prem_Lettre_A ("Pas mal não?") End Sub

A string começa com a ou A

A notação do padrão é [aA]

 Sub Test_a_ou_A () 'Nous allons chercher si un String começa com par "a" ou "A" MsgBox Prem_Lettre_a_ou_A ("alors?") MsgBox Prem_Lettre_a_ou_A ("Ahhh") MsgBox Prem_Lettre_a_ou_A ("Pas mal não?") End Sub Função Prem_Lettre_a_ou_A ( expression As String) Como Booleana Dim reg como conjunto de objetos reg = CreateObject ("vbscript.regexp") 'ici la premiere lettre: ^' doit être: a ou A => [aA] reg.Pattern = "^ [aA]" Prem_Lettre_a_ou_A = reg.test (expressão) End Function

A cadeia começa com uma letra maiúscula

A notação para este padrão é: [AZ]

 Sub Commence_par_Majuscule () MsgBox "todos começam com uma maiúscula:" & Prem_Lettre_Majuscule ("alors?") MsgBox "Início de uma página:" & Prem_Lettre_Majuscule ("Ahhh") MsgBox "Início da página Início da Página & Prem_Lettre_Majuscule ("Pas mal non?") End Sub Função Prem_Lettre_Majuscule (expressão As String) Como Booleana Dim reg Como Objeto Definido reg = CreateObject ("vbscript.regexp") 'ici la premiere lettre: ^' doit être une lettre Majuscule: [AZ] reg.Pattern = "^ [AZ]" Prem_Lettre_Majuscule = reg.test (expressão) End Function

A string termina com

Use a seguinte notação: $

 Sub Fini_Par () MsgBox "Frase: Les RegExp c'est super! Termine par super:" & Fin_De_Phrase ("Les RegExp c'est super!") MsgBox "Frase: C'est super les RegExp! super: "& Fin_De_Phrase (" C'est super les RegExp! ") End Sub Função Fin_De_Phrase (expressão As String) Como Booleana Dim reg como objeto Set reg = CreateObject (" vbscript.regexp ") : super! 'notation de fin de chaîne: $ reg.Pattern = "super! $"' anote o $ se coloque à fin ... Fin_De_Phrase = reg.test (expressão) End Function

A string contém um número

A notação para este padrão é [0-9] . Se você quiser encontrar um número entre 3 e 7: [3-7]

 Sub Contient_un_chiffre () MsgBox "contém um conteúdo chiffre:" & A_Un_Chiffre ("aze1rty") MsgBox "azerty contient un chiffre:" & A_Un_Chiffre ("azerty") End Sub Função A_Un_Chiffre (expressão As String) Como booleano Dim reg como conjunto de objetos reg = CreateObject ("vbscript.regexp") 'não comporter de 0 a 9 n'importe ou (début, milieu, fin de chaine ...) reg.Pattern = "[0-9]"' remarque [0 -9] s'écrité: \ d 'reg.Pattern = "\ d" A_Un_Chiffre = reg.test (expressão) End Function

A string contém um número de 3 dígitos

Vamos agora "quantificar" em nosso RegExp. Para encontrar três ocorrências, usaremos as chaves {}.

 Sub Contient_Un_Nombre_A_trois_Chiffres () MsgBox "contornos azeíficos 3 chiffres:" & Nb_A_Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres:" & Nb_A_Trois_Chiffre ("a1ze2rty3") MsgBox "Contorno azer123ty 3 chiffres:" & Nb_A_Trois_Chiffre ("azer123ty") Fim Função Sub Nb_A_Trois_Chiffre (expressão As String) Como Booleana Dim reg Como Objeto Definido reg = CreateObject ("vbscript.regexp") 'do comporter 3 chiffres de 0 à 9 qui se suivent' le nombre d'occurrence se note {} reg.Padrtern = "\ d {3}" 'équivalant de: reg.Pattern = "[0-9] {3}" Nb_A_Trois_Chiffre = reg.test (expressão) End Function

A string contém 3 números separados

O código

 Sub Contient_trois_Chiffres () MsgBox "contornos azeíficos 3 chiffres séparés:" & Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres séparés:" & Trois_Chiffre ("a1ze2rty3") MsgBox "azer123ty contiente 3 chiffres séparés:" & Trois_Chiffre ("azer123ty ") End Sub Função Trois_Chiffre (expressão As String) Como Booleana Dim Reg Como Objeto Definido reg = CreateObject (" vbscript.regexp ") 'do comporter 3 chiffres de 0 à 9 qui ne se suivent pas' le nombre d'occurrence se note {} 'le point (.) indique n'importe quel caractère sauf le saut de ligne' le + indique que ce qui le précède (ici le point) do itre repreende une ou une infinité de fois reg.Pattern = "(.) + (\ d {1}) (.) + (\ d {1}) (.) + (\ d {1}) "Trois_Chiffre = reg.test (expressão) End Function

Uma variante

 Sub Contient_trois_Chiffres_Variante () MsgBox "contornos azeíficos 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("a1ze2rty3") MsgBox "azer123ty contiente 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("azer123ty ") End Sub Function Trois_Chiffre_Simplifiee (expressão As String) Como Booleana Dim reg como objeto Set reg = CreateObject (" vbscript.regexp ") 'Comme le même motivo: (.) + (\ D {1}) se répète trois fois: reg.Pattern = "(. + \ d {1}) {3}" Trois_Chiffre_Simplifiee = reg.test (expressão) End Function

Exemplo de uso

Em nosso exemplo, o objetivo é determinar se a string é composta da seguinte sequência:

1: A string começa com a palavra "Vis"
2: seguido por um espaço
3: seguido de 1 a 3 letras
4: seguido por um espaço
5: seguido pela letra M
6: seguido por 1 a 2 letras
7: seguido por um hífen
8: seguido de 1 a 3 letras
9: seguido da palavra "classe" rodeada de espaços E em minúsculas
10: acompanhamento de 1-2 letras
11: seguido por um ponto
12: seguido de uma carta

Observe que : Cada bloco do padrão é colocado entre colchetes.

Notação:

1- => (^ Vis)
2- => ()
3- => ([a-zA-Z] {1, 3})
4- => () --- Nota: no aurait pu l'insérer avec le M qui suit ... Mis pour l'exemple
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})

Isso nos dá o seguinte padrão

"(^ 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 () Se VerifieMaChaine ("xx Visxx Mxx-x classe xx.x") Então MsgBox "bom" Else MsgBox "pas glop" End Se 'manque l'espace avant le M: Se VerifieMaChaine ("Vis xxMxx-x classe xx.x ") Then MsgBox" good "Outra MsgBox" pas glop "End If End Sub Função VerifieMaChaine (expression As String) Como Booleana Dim reg como objeto Set reg = CreateObject (" vbscript.regexp ") 'Há um exemplo mais simples, mas este é o mais completo reg.Padron = "(^ 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}) "VerifieMaChaine = reg.test (expressão) End Function End Sub