VBA - Espressioni regolari

Questo tutorial mira a spiegare tutte le complessità relative all'uso delle espressioni regolari. Imparerai come navigare attraverso le stringhe per trovare sottostringhe usando le espressioni regolari (comunemente chiamate RegExp ).

Prerequisiti

Nell'editor VBA.

Vai al menu Strumenti> Riferimenti.
Sfoglia i vari riferimenti e controlla la seguente opzione "Microsoft VBScript Regular Expression 5.5".

Sintassi e dichiarazione

In questi esempi, gli unici termini che dovremo richiedere sono:

La dichiarazione

Sono disponibili due opzioni:

Come oggetto

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

VBScript_RegExp_55.regexp

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

Le proprietà

Indipendentemente da come hai dichiarato RegExp, le proprietà avranno la stessa sintassi.

Il modello

Il modello deve essere conforme alla sottostringa. Ti permette di navigare attraverso la stringa.

 reg.Pattern = "IciLeMotif"

Test

Verificheremo la stringa, se il modello è stato trovato, restituisce il seguente valore booleano: Vero.

 reg.Test = "IciLeMotif"

La stringa inizia con A (maiuscolo)

Il modello sarebbe:

all'inizio della stringa
c'è un A

La notazione di questo modello è: ^ A

 Funzione Prem_Lettre_A (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject ("vbscript.regexp") 'Le Pattern est le motif que l'on recherche' début de chaîne: ^ 'doit être: A reg.Pattern = "^ A" 'le test renvoie un Boolean (parfait pour notre fonction Booléenne !!!) Prem_Lettre_A = reg.test (espressione) End Function

Per chiamare la funzione:

 Sub Test_A () 'Nous allons chercher si un String inizio da "A" Majuscule MsgBox Prem_Lettre_A ("alors?") MsgBox Prem_Lettre_A ("Ahhh") MsgBox Prem_Lettre_A ("Pas mal non?") End Sub

La stringa inizia con a o A

La notazione del modello è [aA]

 Sub Test_a_ou_A () 'Nous allons chercher si un String inizio da "a" o "A" MsgBox Prem_Lettre_a_ou_A ("alors?") MsgBox Prem_Lettre_a_ou_A ("Ahhh") MsgBox Prem_Lettre_a_ou_A ("Pas mal non?") End Sub Function Prem_Lettre_a_ou_A ( espressione As String) As Boolean Reg reg As Object Set reg = CreateObject ("vbscript.regexp") 'ici la première lettre: ^' doit être: a ou A => [aA] reg.Pattern = "^ [aA]" Prem_Lettre_a_ou_A = reg.test (espressione) End Function

La stringa inizia con una lettera maiuscola

La notazione per questo modello è: [AZ]

 Sub Commence_par_Majuscule () MsgBox "alors? Comence par une majuscule:" & Prem_Lettre_Majuscule ("alors?") MsgBox "Ahhh inizio une majuscule:" & Prem_Lettre_Majuscule ("Ahhh") MsgBox "Pas mal non? Comence par une majuscule:" & Prem_Lettre_Majuscule ("Pas mal non?") End Sub Function Prem_Lettre_Majuscule (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject ("vbscript.regexp") 'ici la première lettre: ^' doit être une lettre Majuscule: [AZ] reg.Pattern = "^ [AZ]" Prem_Lettre_Majuscule = reg.test (espressione) End Function

La stringa finisce con

Usa la seguente notazione: $

 Sub Fini_Par () MsgBox "La frase: Les RegExp c'est super! Se termine par super:" & Fin_De_Phrase ("Les RegExp c'est super!") MsgBox "La frase: C'est super les RegExp! Se termine par super: "& Fin_De_Phrase (" C'est super les RegExp! ") End Sub Function Fin_De_Phrase (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject (" vbscript.regexp ") 'La fin de la chaine doit être : super! 'notation de fin de chaîne: $ reg.Pattern = "super! $"' note le $ se posto alla fine ... Fin_De_Phrase = reg.test (espressione) End Function

La stringa contiene un numero

La notazione per questo modello è [0-9] . Se si desidera trovare un numero compreso tra 3 e 7: [3-7]

 Sub Contient_un_chiffre () MsgBox "aze1rty contient un chiffre:" & A_Un_Chiffre ("aze1rty") MsgBox "azerty contient un chiffre:" & A_Un_Chiffre ("azerty") End Sub Function A_Un_Chiffre (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject ("vbscript.regexp") "doit comporter un chiffre de 0 à 9 n'importe ou (debutto, milieu, fin de chaine ...) reg.Pattern =" [0-9] "'remarque [0 -9] s'écrit également: \ d 'reg.Pattern = "\ d" A_Un_Chiffre = reg.test (espressione) End Function

La stringa contiene un numero a 3 cifre

Ora "quantificeremo" nel nostro RegExp. Per trovare tre occorrenze, utilizzeremo le parentesi graffe {}.

 Sub Contient_Un_Nombre_A_trois_Chiffres () MsgBox "aze1rty contient 3 chiffres:" & Nb_A_Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres:" & Nb_A_Trois_Chiffre ("a1ze2rty3") MsgBox "azer123ty contient 3 chiffres:" & Nb_A_Trois_Chiffre ("azer123ty") Fine Sub Function Nb_A_Trois_Chiffre (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject ("vbscript.regexp") 'doit comporter 3 chiffres de 0 à 9 qui se suivent' il nombre d'occorrenza se nota {} reg.Pattern = "\ d {3}" 'équivalant de: reg.Pattern = "[0-9] {3}" Nb_A_Trois_Chiffre = reg.test (espressione) End Function

La stringa contiene 3 numeri separati

Il codice

 Sub Contient_trois_Chiffres () MsgBox "aze1rty contient 3 chiffres séparés:" & Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres séparés:" & Trois_Chiffre ("a1ze2rty3") MsgBox "azer123ty contient 3 chiffres séparés:" & Trois_Chiffre ("azer123ty ") End Sub Function Trois_Chiffre (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject (" vbscript.regexp ") 'doit comporter 3 chiffres de 0 à 9 qui ne se suivent pas' il nombre d'occorrenza se nota {} '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) doit être représenté une o une infinité de fois reg.Pattern = "(.) + (\ d {1}) (.) + (\ d {1}) (.) + (\ d {1}) "Trois_Chiffre = reg.test (espressione) Fine Funzione

Una variante

 Sub Contient_trois_Chiffres_Variante () MsgBox "aze1rty contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("a1ze2rty3") MsgBox "azer123ty contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ("azer123ty ") End Sub Function Trois_Chiffre_Simplifiee (espressione As String) As Boolean Dim reg As Object 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 (espressione) End Function

Esempio di utilizzo

Nel nostro esempio, l'obiettivo è determinare se la stringa è composta dalla seguente sequenza:

1: la stringa inizia con la parola "Vis"
2: seguito da uno spazio
3: seguito da 1 a 3 lettere
4: seguito da uno spazio
5: seguito dalla lettera M
6: seguito da 1 a 2 lettere
7: seguito da un trattino
8: seguito da 1 a 3 lettere
9: seguito dalla parola "classe" circondata da spazi AND in lettere minuscole
10: follow-up di 1-2 lettere
11: seguito da un punto
12: seguito da una lettera

Nota : ogni blocco del modello è racchiuso tra parentesi.

Notazione:

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

Questo ci dà il seguente schema

"(^ 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}) "

Il codice:

 Sub Main () Se VerifieMaChaine ("Vis xx Mxx-x classe xx.x") Allora MsgBox "buono" Else MsgBox "pas glop" End If "manque l'espace avant le M: Se VerifieMaChaine (" Vis xxMxx-x classe xx.x ") Quindi MsgBox" buono "Else MsgBox" pas glop "End If End Sub Function VerifieMaChaine (espressione As String) As Boolean Dim reg As Object Set reg = CreateObject (" vbscript.regexp ") 'Ci sono esempi più semplici, ma questo è il più completo 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}) "VerifieMaChaine = reg.test (espressione) End Function End Sub