VBA - Initiation aux expressions rationnelles
- Introduction
- Référence à cocher
- Syntaxe et déclaration
- Les propriétés à connaitre pour ce tutoriel
- La chaîne commence par "A" Majuscule
- Commence par a ou A
- Commence par une lettre Majuscule
- Se termine par
- Contient un chiffre
- Contient un nombre à 3 chiffres
- Contient 3 chiifres séparés
- Exemple concret
- Conclusion & téléchargement
Introduction
Ce tutoriel est loin de vous expliquer toutes les subtilités liées aux expressions rationnelles. Nous n'allons aborder ici que le préambule à leur utilisation. Il existe d'autres tutoriels bien plus documentés sur Internet.
Le but ici est d'apprendre à parcourir des chaînes (String), d'y trouver des sous-chaînes grâce à un motif. Ce motif sera indiqué par un schéma, une notation particulière : l'expression rationnelle.
Nous allons donc découvrir les Expressions Rationnelles (plus communément appelées RegExp) par l'exemple.
Référence à cocher
Dans votre éditeur VBA, dans le menu outils, allez dans références.
Parcourez les différentes références et cochez : "Microsoft vbscript regular expression 5.5"
Syntaxe et déclaration
Dans ces exemples, les seuls termes dont nous aurons besoin sont :
La déclaration
Deux possibilités s'offrent à nous :
As Object
Probablement la plus simple à retenir...
Le code :
Dim reg As Object Set reg = CreateObject("vbscript.regexp")
VBScript_RegExp_55.regexp
Cette notation est probablement plus conventionnelle.
Dim reg As VBScript_RegExp_55.regexp Set reg = New VBScript_RegExp_55.regexp
Les propriétés à connaitre pour ce tutoriel
Peu importe comment vous avez déclaré votre RegExp, les propriétés auront la même syntaxe.
Pattern
Le Pattern représente le motif que doit respecter la sous-chaîne. Il est ce que nous allons chercher à trouver dans la chaîne. Sa notation revêt un caractère de simplification lorsque l'on utilise les expressions régulières.
Le code correspondant :
reg.Pattern = "IciLeMotif"
Test
Comme son nom l'indique, va tester la chaîne et, si le Pattern (motif) y figure, va revoyer True. Il s'agit d'un Boolean.
Le code correspondant :
reg.Test(expression_à_tester)
Ceci étant vu, nous pouvons commencer nos exemples.
La chaîne commence par "A" Majuscule
Le Pattern serait donc :
- en début de chaîne,
- il y a un A
La notation de ce motif est : ^A, tout simplement, que l'on placera entre guillemets.
Function Prem_Lettre_A(expression 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(expression) End Function
La procédure d'appel pour tester :
Sub Test_A() 'Nous allons chercher si un String commence par "A" Majuscule MsgBox Prem_Lettre_A("alors?") MsgBox Prem_Lettre_A("Ahhh") MsgBox Prem_Lettre_A("Pas mal non?") End Sub
Commence par a ou A
Ici, nous allons simplement identifier la première lettre, sans respecter de casse.
La notation pour la lettre a sans tenir compte de la casse est : [aA]
Sub Test_a_ou_A() 'Nous allons chercher si un String commence 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 non?") End Sub Function Prem_Lettre_a_ou_A(expression As String) As Boolean Dim 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(expression) End Function
Commence par une lettre Majuscule
Peu importe la lettre, tant que celle-ci est en majuscule. La simplicité des RegExp, et surtout de sa notation nous donne : [A-Z]
Sub Commence_par_Majuscule() MsgBox "alors? commence par une majuscule : " & Prem_Lettre_Majuscule("alors?") MsgBox "Ahhh commence par une majuscule : " & Prem_Lettre_Majuscule("Ahhh") MsgBox "Pas mal non? commence par une majuscule : " & Prem_Lettre_Majuscule("Pas mal non?") End Sub Function Prem_Lettre_Majuscule(expression As String) As Boolean Dim reg As Object Set reg = CreateObject("vbscript.regexp") 'ici la première lettre : ^ 'doit être une lettre Majuscule : [A-Z] reg.Pattern = "^[A-Z]" Prem_Lettre_Majuscule = reg.test(expression) End Function
Se termine par
Jusqu'alors nous avions vu "commence par", soit ^. La chaîne se termine par se note : $, tout simplement.
Sub Fini_Par() MsgBox "La phrase : Les RegExp c'est super! se termine par super : " & Fin_De_Phrase("Les RegExp c'est super!") MsgBox "La phrase : C'est super les RegExp! se termine par super : " & Fin_De_Phrase("C'est super les RegExp!") End Sub Function Fin_De_Phrase(expression 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 place à la fin... Fin_De_Phrase = reg.test(expression) End Function
Contient un chiffre
La notation de "un chiffre" coule de source. [0-9].
Si nous avions souhaité trouver un chiffre entre 3 et 7 nous aurions pu écrire : [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(expression As String) As Boolean Dim reg As Object Set reg = CreateObject("vbscript.regexp") 'doit comporter un chiffre de 0 à 9 n'importe ou (début, milieu, fin de chaine...) reg.Pattern = "[0-9]" 'remarque [0-9] s'écrit également : \d 'reg.Pattern = "\d" A_Un_Chiffre = reg.test(expression) End Function
Contient un nombre à 3 chiffres
Nous allons maintenant "quantifier" dans notre RegExp. Pour écrire au code qu'il faut trouver 3 occurrences, il convient d'utiliser les accolades : {}.
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") End Sub Function Nb_A_Trois_Chiffre(expression As String) As Boolean Dim reg As Object Set reg = CreateObject("vbscript.regexp") 'doit comporter 3 chiffres de 0 à 9 qui se suivent 'le nombre d'occurrence se note {} reg.Pattern = "\d{3}" 'équivalant de : reg.Pattern = "[0-9]{3}" Nb_A_Trois_Chiffre = reg.test(expression) End Function
Contient 3 chiifres séparés
Code
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(expression 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 '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) doit être représenté une ou une infinité de fois reg.Pattern = "(.)+(\d{1})(.)+(\d{1})(.)+(\d{1})" Trois_Chiffre = reg.test(expression) End Function
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(expression As String) As Boolean Dim reg As Object Set reg = CreateObject("vbscript.regexp") 'Comme le même motif : (.)+(\d{1}) se répète trois fois : reg.Pattern = "(.+\d{1}){3}" Trois_Chiffre_Simplifiee = reg.test(expression) End Function
Exemple concret
Ici le but sera de définir si la chaine est un enchainement précis de :
- 1 : Le mot Vis au début de la chaine,
- 2 : suivi d'un espace,
- 3 : suivi de 1 à 3 lettres,
- 4 : suivi d'un espace,
- 5 : suivi de la lettre M,
- 6 : suivie de 1 à 2 lettres,
- 7 : suivie d'un tiret,
- 8 : suivi de 1 à 3 lettres,
- 9 : suivi du mot classe entouré d'espace ET en minuscules,
- 10 : suivi d'1 à 2 lettres,
- 11 : suivi d'un point,
- 12 : suivi d'une lettre.
A savoir :
Chaque bloc du motif est entouré de parenthèses.
Notation :
1- => (^Vis) ^ représente le début de la chaine et Vis respecte la casse (Majusc, minusc)
2- => ( )
3- => ([a-zA-Z]{1,3})
4- => ( ) --- Note : on 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})
Ce qui nous donne le motif suivant :
"(^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})"
Le code :
Sub Main() If VerifieMaChaine("Vis xx Mxx-x classe xx.x") Then MsgBox "good" Else MsgBox "pas glop" End If 'manque l'espace avant le M : If VerifieMaChaine("Vis xxMxx-x classe xx.x") Then MsgBox "good" Else MsgBox "pas glop" End If End Sub Function VerifieMaChaine(expression As String) As Boolean Dim reg As Object Set reg = CreateObject("vbscript.regexp") 'Il y a forcément plus simple, mais c'est juste un exemple pour être le plus clair possible 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(expression) End Function End Sub
Conclusion & téléchargement
Les codes donnés dans ce tutoriel sont tous réunis dans ce classeur exemple.
Vous pouvez maintenant tester des chaînes sans avoir d'exactitude sur la sous-chaine à y trouver.
Je vous invite à aller voir d'autres tutoriels à ce sujet, notamment, pour continuer l'apprentissage, celui de caféine.