Simplifier une Expression Rationnelle

**antonysansh** · 31/05/2016, 11h29

Bonjour à tous,

Comme l'indique l'intitulé de la discussion, je cherche à simplifier une RegExp.

Tout d'abord j'ai suivi le très bon tutoriel : Les Expressions Rationnelles appliquées en VBA Access

Ma problématique vient de l'utilisation du quantificateur {x} pour répéter des motifs

Avec :

la chaine "0.1.2.3.4.5.6.7.8.9"
le pattern (\d)\.(\d)\.(\d)\.(\d)\.(\d)\.(\d)\.(\d)\.(\d)\.(\d)\.(\d)

=> le test est True avec les 10 motifs "0", "1", "2", ... "8" et "9"

J'aimerais simplifier l'écriture car dans mon cas réel il ne s'agit pas de simple digits séparé d'un "." mais de motif comme ceci : [A-Z]{3}\d\d[A-Z]{2} (ABC12DE) séparé d'un "."
De plus il n'y en a pas 10 mais 32.

Le pattern va donc être :
([A-Z]{3}\d\d[A-Z]{2})\.([A-Z]{3}\d\d[A-Z]{2})\. ...................... \.([A-Z]{3}\d\d[A-Z]{2}) (32 fois)
En terme de maintenance on devine déjà que ça ne va pas être pratique.

Comment simplifier l'expression en faisant probablement intervenir {31} pour avoir mes 32 motifs ?

PS :

Dans le tutoriel ci-dessus, il y a l'exemple d'une adresse IP qui est constitué de 4 nombres <= 255 séparés d'un "." mais malheureusement le pattern du tutoriel ne renvoie pas les 4 motifs. (J'ai bien testé je vous le promets)
Je sais qu'un split pourrait être utilisé ici mais la méthode .Join sur un tableau est beaucoup moins puissante qu'un RegExp.Replace en terme de possibilité et de maintenance.

**Zirak** · 31/05/2016, 15h05

Bonjour,

Si je suis le tutoriel, je dirais quelque chose comme ceci :

reg.Pattern = "^(([A-Z]{3}\d\d[A-Z]{2})\.){31}([A-Z]{3}\d\d[A-Z]{2})$"

Il me semble que cela correspond à ce que tu cherches à faire, cela me retourne bien true pour une chaine de 32 éléments séparés par un "." si le pattern est respecté et false sinon.

**antonysansh** · 31/05/2016, 15h25

Merci Zirak pour ta réponse mais malheureusement ça ne fonctionne pas.
Cette partie du tutoriel ne fonctionne pas sur les motifs. Le Test est juste encore que je ne suis pas si sur.

J'avais testé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Sub test()
    AllRegExp "POI42AB.PIO40AC.POI42DG", "^(([A-Z]{3}\d\d[A-Z]{2})\.){2}([A-Z]{3}\d\d[A-Z]{2})$", ""
End Sub

Avec la fonction fourni dans le tuto :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Function AllRegExp(ByVal strSource As String, _
                   ByVal strPattern As String, _
                   ByVal strReplace As String)

J'ai ça comme rendu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
==================================
      Travaux liés à .Execute
==================================
source >>     POI42AB.PIO40AC.POI42DG
[$1]          PIO40AC.
[$2]          PIO40AC
[$3]          POI42DG
==================================
        Travaux liés à .Test
==================================
Vrai

.Test est bien à VRAI mais les motifs sont faux et il y a un "." qui traine.

**Zirak** · 31/05/2016, 15h58

Je t'avoue que je n'ai pas testé au niveau du retour de chaque partie de la chaine (je ne me sers jamais de cette fonction, donc il y a surement des subtilités que je ne connais pas).

Mais juste sur le test pour voir si la chaine correspond bien au pattern, j'ai essayé sur plusieurs chaines, c'est tombé juste à chaque fois, donc le pattern en lui-même est bon.

Maintenant, si je suis le tuto, il s'agit de vérifier la présence d'un pattern au sein d'une chaine, puis d'afficher les différents éléments, alors que dans ton cas, le pattern correspond à la chaine entière, ce qui entraine peut-être ce dysfonctionnement ?

Car si je test ceci en simplifiant le pattern (pour vérifier la présence d'une ou plusieurs sous-chaines de type ABD12AB dans ta chaine de 32 éléments), cela me retourne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 Call AllRegExp(CStr(Range("B2")), "([A-Z]{3}\d\d[A-Z]{2})", "")

Je retrouve bien mes 32 éléments.

Au final, tu veux juste vérifier si le pattern de ta chaine est juste, ou tu as besoin de récupérer les différents éléments de ta chaine pour travailler dessus (et faire quoi dessus ?) ?

EDIT:

Envoyé par antonysansh

.Test est bien à VRAI mais les motifs sont faux et il y a un "." qui traine.

Alors le "." qui traine oui, mais attention, les motifs ne sont pas faux, la chaine que tu lui passe en argument, correspond bien au pattern passé lui aussi en argument, donc c'est normal que cela te retourne "vrai".

' Utilisation de .Test
' pour savoir si le motif a été trouvé sur la chaîne source

Pour moi ce n'est pas fait pour t'indiquer si chaque sous-chaine a le bon motif.

**antonysansh** · 31/05/2016, 16h17

Dans ton exemple c'est la propriété .Global a True qui renvoi toutes les sous-chaines qui match.

Ce que je veux faire c'est récupérer mes 32 motifs pour les réorganiser selon les cas. Dans mes cas je ne vais pas toujours retourner les 32 motifs et pas toujours avec le même séparateur entre eux.

Dans un cas par exemple je vais renvoyer $1.$2.$3 => $4
dans d'autre $10-$20+$30 = $14

D'où le fait de passer par une RegExp car un Split / Join ne me permets pas la réorganisation des la chaines.

**Zirak** · 31/05/2016, 16h33

Envoyé par antonysansh

Dans ton exemple c'est la propriété .Global a True qui renvoi toutes les sous-chaines qui match.

Non.

La propriété .Global permet de définir si l'on traite seulement la 1ère occurrence, ou toutes, ensuite c'est la boucle qui retourne les résultats correspondants :

que la variable soit à true ou false si ton motif n'est pas trouvé dans ta chaine => 0 retour
que la variable soit à true ou false si ton motif n'est présent qu'une fois dans ta chaine => 1 retour

Il n'y a que dans le cas où ton motif est présent plusieurs fois, qu'en fonction de ta variable, tu auras 1 ou plusieurs retours.

Envoyé par antonysansh

Ce que je veux faire c'est récupérer mes 32 motifs pour les réorganiser selon les cas. Dans mes cas je ne vais pas toujours retourner les 32 motifs et pas toujours avec le même séparateur entre eux.

Dans un cas par exemple je vais renvoyer $1.$2.$3 => $4
dans d'autre $10-$20+$30 = $14

D'où le fait de passer par une RegExp car un Split / Join ne me permets pas la réorganisation des la chaines.

1ère question :

Au final, tes traitements avec tes motifs, pour les faire, as-tu besoin que la chaine complète respecte le schéma ABC12DE x32 avec le point comme séparateur ?

2ème question :

Si une ou plusieurs des sous-chaines n'a/ont pas le bon motif au sein de ta chaine, tu dois récupérer les sous-chaines concernées seulement ?
Tu peux en récupérer des "avec", et des "sans" le bon motif dans le même traitement ?

3ème question :

Au final, quelles sont tes règles pour faire tes différents traitements ?

Car tu dis que selon les cas, tu vas faire tel ou tel traitement, donc tu ne vas pas pouvoir tout gérer avec une seule regex, tu vas bien être obligé d'intercaler du VBA pour tester "je ne sais quoi", pour orienter ton traitement d'un côté ou de l'autre non ?

**antonysansh** · 31/05/2016, 16h24

Envoyé par Zirak

Pour moi ce n'est pas fait pour t'indiquer si chaque sous-chaine a le bon motif.

Je ne suis pas entièrement d'accord.

Car le pattern "^\d{10}$" va être vrai uniquement si mon entrée est un nombre de 10 chiffres. "0123456789" est VRAI mais pas de motifs renvoyé

Par contre "^(\d{5})(\d{5})$" va être vrai uniquement si mon entrée commence par un nombre de 5 chiffres et fini par un nombre de 5 chiffres avec rien entre les deux (donc un nombre de 10 chiffres).
"0123456789" va être VRAI avec comme motifs $1 = "01234" et $2 = "56789"

**Zirak** · 31/05/2016, 16h40

Envoyé par antonysansh

Je ne suis pas entièrement d'accord.

Car le pattern "^\d{10}$" va être vrai uniquement si mon entrée est un nombre de 10 chiffres. "0123456789" est VRAI mais pas de motifs renvoyé

Par contre "^(\d{5})(\d{5})$" va être vrai uniquement si mon entrée commence par un nombre de 5 chiffres et fini par un nombre de 5 chiffres avec rien entre les deux (donc un nombre de 10 chiffres).
"0123456789" va être VRAI avec comme motifs $1 = "01234" et $2 = "56789"

Je pense que les parenthèses jouent beaucoup, je m'explique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Call AllRegExp(CStr(Range("B4")), "^\d{10}$", "")

me renvoi effectivement (sans retour) :

==================================
Travaux liés à .Execute
==================================
source >> 2123456789
==================================
Travaux liés à .Test
==================================
Vrai
==================================
Travaux liés à .Replace
==================================

Alors que,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Call AllRegExp(CStr(Range("B4")), "^(\d{10})$", "")

me renvoi la même chose (mais avec le retour) :

==================================
Travaux liés à .Execute
==================================
source >> 2123456789
[$1] 2123456789
==================================
Travaux liés à .Test
==================================
Vrai
==================================
Travaux liés à .Replace
==================================

Les sous-motifs capturés entre parenthèses sont mis dans des variables de type Perl $1, $2 ... $n

Si tu ne mets pas de parenthèses, c'est normal que tu n'ais pas de retour de ce que j'en comprends.

Simplifier une Expression Rationnelle [XL-2010]

Macros et VBA Excel

Vue hybride

Discussions similaires

Partager

Partager