Expression réguliere incrémentable

[Ekim]

Bonsoir à tous, est-il possible d'incrémenter de 1 une expression régulière?


par exemple:

HFGTFR5a1
HFGTFR5a2
HFGTFR5a3
HFGTFR5a4
HFGTFR5a5
HFGTFR5a6

[Marc56]

Une expression régulière est "compilée" avant d'être exécutée, elle ne peut donc pas changer à chaque itération.

Ta demande n'est pas assez détaillée.

Souhaites-tu avoir:

• HFGTFR5a suivi d'un chiffre de 1 à 6 au choix ?
• Trouver un texte balisé par les six (ou plus) balises commençant par HFGTFR5a et un chiffre consécutif ?

[omega]

Bonjour,
Incrémenter l'expression de 1 à 6

Code : Tout sélectionner

Exp$="HFGTFR5a"
Dim TExp$(6)
For i=1 to 6
   TExp$(i)=Exp$+str(i)
   debug  TExp$(i)
Next 

[Ar-S]

Comme l'a dit Marc56, pas sûr que ta demande concerne les expressions régulières.
Si tu veux incrémenter une variable c'est tout bête.

Code : Tout sélectionner

MaSuite.s ="H4dz23A" ; ta chaine de base
For i = 1 To 6
Increm.s = MaSuite.s + Str(i) ; Increm est la nouvelle chaine de caractères à laquelle tu vas combiner MaSuite et valeur de i
Debug Increm
Next

[Ekim]

Bien essayé @omega))
mais en fait je voulais inclure la librairie "RegEx" (expression régulière)

@Marc56
Oui tu as raison, je rectifie l'exemple:

HFGTFR5a1
HFGTFR5a2
HFGTFR5a3
HFGTFR5a4
HFGTFR5a5
HFGTFR5a6
....
jusqu'à l'infini
HFGTFR5a6+N si tu veux

et pour plus de précision, je souhaiterais que l'incrémentation se fasse par l'expression régulière elle-même
sur l'exemple du dessous, j'avais expérimenté un système mais sans succès car il comporte 2 défauts, après une itération de 10 sa part en vrille(((

c'est pour ça que je souhaiterais trouver une méthode entièrement géré par la lib RegEx afin d'évité les "tour processeur" et donc d'évité les erreurs de traitement

Code : Tout sélectionner

R3$ ="HFGTFR5a1"

CodeBash$ = ReverseString(R3$)
;CodeBash$ = R3$

df$="\d+"

If CreateRegularExpression(0, df$)
	Dim Resultat$(1)
	
	Repeat 
		ExtractRegularExpression(0, CodeBash$, Resultat$())
		
		resnb$ = Resultat$(0)
		
		Tclb = Len(resnb$)
		
		If Tclb > 1
			res$=RSet(Str(Val(resnb$)+a),Tclb,"0") ; Afin de respecter le format ainsi capturé
		Else
			res$=Str(Val(resnb$)+a)
		EndIf
		
		ReplaceString(CodeBash$,resnb$,res$,#PB_String_InPlace|#PB_String_CaseSensitive,1,1) ; là où sa coince je pense
		
		Debug ReverseString(CodeBash$)
		;Debug CodeBash$
		
		a=1 ; incrémentation de 1
		
		i=i+1
	Until i=20 ;Histoire de sortir de l'exemple!
Else
	Debug RegularExpressionError()
EndIf

voilà l'usine à gaz))
je pense que je me suis compliqué la vie pour rien c'est possible aussi)))))))

[Marc56]

Je ne comprends toujours pas trop mais bon, si le but est de créer une expression incrémentale et de l'utiliser en boucle, il suffit de la recréer et de la libérer à chaque boucle.
Avec ça:

Code : Tout sélectionner

R3$ ="HFGTFR5a"

For i = 1 To 12
	RegEx$ = R3$ + Str(i)
	If CreateRegularExpression(0, RegEx$)
		Debug "RegEx: " + RegEx$
		
		; ... Extraction avec la nouvelle RegEx
		
	EndIf
	FreeRegularExpression(0)
Next

On obtient ça:

Code : Tout sélectionner

RegEx: HFGTFR5a1
RegEx: HFGTFR5a2
RegEx: HFGTFR5a3
RegEx: HFGTFR5a4
RegEx: HFGTFR5a5
RegEx: HFGTFR5a6
RegEx: HFGTFR5a7
RegEx: HFGTFR5a8
RegEx: HFGTFR5a9
RegEx: HFGTFR5a10
RegEx: HFGTFR5a11
RegEx: HFGTFR5a12

Si ce n'est pas cela que tu souhaites, un exemple (même bidon) du texte à trouver, ce serait bien

[Marc56]

Ou alors, si tu veux extraire en une seule fois des éléments ayant des numéros consécutifs.
Texte$ étant par exemple un fichier de références à extraires

Code : Tout sélectionner

EnableExplicit

Enumeration 
	#ID_RegEx
EndEnumeration

; Texte source pour la recherche
Define Texte$ = "Référence_A1:Trucs;Référence_A2:Machins;Référence_A3:Bidules;Référence_A4:Choses;Référence_A5:Autres;"

; Balise de référence
Define R3$ ="Référence_A"

; Construction de la chaine incrémentale
Define i, RegEx$
For i = 1 To 5
	RegEx$ = RegEx$ + R3$ + Str(i) + ":(.+);"
Next

If CreateRegularExpression(#ID_RegEx, RegEx$, #PB_RegularExpression_DotAll)
	If ExamineRegularExpression(#ID_RegEx, Texte$)
		Define j = CountRegularExpressionGroups(#ID_RegEx)
		Debug "" + j + " Référence(s) trouvée(s)" + #CRLF$
		While NextRegularExpressionMatch(#ID_RegEx)
			For j = 1 To 5
				Debug "#" + j + " : " + RegularExpressionGroup(#ID_RegEx, j)
			Next
		Wend	
	EndIf
Else
	Debug "No match" + RegularExpressionError()
EndIf	

FreeRegularExpression(#ID_RegEx)

End

Va extraire tout ce qui se trouve entre Référence_A<1 à x>:(le texte à extraire);

Code : Tout sélectionner

5 Référence(s) trouvée(s)

#1 : Trucs
#2 : Machins
#3 : Bidules
#4 : Choses
#5 : Autres

Inconvénient:
- Il faut connaitre avant de créer la RegEx le nombre d'éléments (mais on peut faire un premier passage pour compter avec une RegEx ou avec CountString()
- Cela peut être lent s'il y a beaucoup de captures à faire. (à tester par rapport à une solution à base de lib String)

[Ekim]

@Ar-S
Oui je comprends parfaitement le doute du projet

pour info ceci représente un seul module parmi d'autre
le but étant de capturer certains éléments précis dans un bloc de texte brute et de les faire itérer chacun leur tour jusqu'au maximum de leur point
mais comme les blocs texte diffèrent à chaque fois des précédents, il est donc impossible de prévoir la forme de ces éléments en avance et encore moins de définir leurs itérations, de ce fait, le recourt à la Lib RegEx est inévitable

@Marc56
Merci pour ton exemple qui ce révèle aussi compliqué que le mien finalement)))))
mais qui comporte néanmoins beaucoup de détails intéressants et que je reprendrais certainement

[Ar-S]

mais comme les blocs texte diffèrent à chaque fois des précédents

Ok mais la vraie question est : les connait-on à l'avance ou le prog doit il simplement trouver des doublons ?
Parce que si tu les connais à l'avance, un FindString + compteur devraient suffire.

[Ekim]

@Ar-S
Non, malheureusement mon module doit partir de rien, le seul indice qu'il aura à sa disposition c'est la forme que devrait avoir le bout de texte à capturer

mais aujourd'hui même je viens de comprendre après documentations que c'est impossible d'avoir recourt uniquement à du RegEx à 100% car il n'offre aucune routine et ne possède aucune fonctionnalités d'incrémentation/décrémentation..... dommage

[Marc56]

Non, malheureusement mon module doit partir de rien, le seul indice qu'il aura à sa disposition c'est la forme que devrait avoir le bout de texte à capturer

mais aujourd'hui même je viens de comprendre après documentations que c'est impossible d'avoir recourt uniquement à du RegEx à 100% car il n'offre aucune routine et ne possède aucune fonctionnalités d'incrémentation/décrémentation..... dommage

Premier passage pour relever les balises. RegEx à utiliser: "\bHFGTFR5a[\d]+\b"
Chaque balise trouvée est enregistrée dans une map (pour éviter les doublons)
Deuxième passage en boucle avec chacune des RegEx

Note:
\b = boundary (limite) = Espace ou Tab ou saut de ligne.
Ça empêche le caractère gourmand de la regex, c'est à dire l’empêche de prendre plus que ce qui est défini.
Selon le cas, tu peux remplacer par autre chose (ex: ";")

Une RegEx est compilée en mémoire avant utilisation, elle ne peut donc être modifiée en cours d'itération, mais on peut toujours la libérer (FreeRegularExpression) et la refaire à chaque boucle.

[Ekim]

Une RegEx est compilée en mémoire avant utilisation, elle ne peut donc être modifiée en cours d'itération, mais on peut toujours la libérer (FreeRegularExpression) et la refaire à chaque boucle.

effectivement ça c'est une chouette idée)