RegExp récupérer Submatches ?

[NeriXs]

Bonjour,
Je bute sur la récupération des Submatches des (groups) de mon pattern.
J’espère que ce que j’essaie de faire est réalisable?
Pouvez-vous m’aider?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
TxtSource = "\\\*-****/Un test, Pourquoi faire? c'est fou ça! \****-*///"
ReslutSpeciChars = ""	
 
Dim strText, RegularExpressioN
 
'([^\,]|^)([\,])(?![\,])
'[^\,] = n'est pas une virgule. 
'| = ou.
'^ = est au début de la chaîne.
'(?![\,]) = n'est pas suivit d'une virgule.
'Equivalent a (?<![\,])[\,](?![\,]) soit (pas de virgule avant, pas de virgule après), mais non supporter par vb (test arrière (?<!....).
 
'"\" =([^\\]|^)([\\])(?![\\])
'"/" =([^\/]|^)([\/])(?![\/])
'"*" =([^\*]|^)([\*])(?![\*])
 
FindSpeciChars = "([^\\]|^)([\\])(?![\\])"_
	       & "|([^\/]|^)([\/])(?![\/])"_
	       & "|([^\*]|^)([\*])(?![\*])"
 
	strText = TxtSource		
	Set RegularExpressioN = New RegExp
	RegularExpressioN.Pattern = FindSpeciChars
	RegularExpressioN.Global = True
	Set Matches = RegularExpressioN.Execute(strText)
		If Matches.Count > 0 Then		  
		    MatchMsg = Matches.Count & " correspondance(s) trouvée(s)." & vbCRLF
		    	For Each Match In Matches
		      		MatchMsg = MatchMsg & "Correspondance trouvée """ & match.Submatches(1) & """ en position: " & match.FirstIndex + Len(match.SubMatches(0)) & vbCrLf
		    	Next
		    'MsgBox MatchMsg
		Else
		    MsgBox "Aucun match", 0, "VBScript RegExp Tester"
		End If		  										
	strText = RegularExpressioN.Replace(strText, "$&")'"$1" "$&"
	Set RegularExpressioN = Nothing
	ReslutSpeciChars = strText
 
MsgBox TxtSource & vbCrLf & ReslutSpeciChars & vbCrLf & MatchMsg

[NeriXs]

Bonjour,
Bon je parviens à remplacer est à récupérer\positionner les bonnes valeurs des caractères spéciaux qui ne font pas partie d'un groupe de caractères identiques "isolé".
Je rencontre un autre problème si deux caractères isolés sont côte à côte, seule le 1er est pris en compte.
Ça se complique grave.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
TxtSource = "\-\\\*-****/Un test, Pourquoi faire? c'est fou ça! \****-*/// /" 
ReslutSpeciChars = "" 
 
Dim strText, RegularExpressioN
 
'([^\,]|^)([\,])(?![\,])
'[^\,] = n'est pas une virgule. 
'| = ou.
'^ = est au début de la chaîne.
'(?![\,]) = n'est pas suivit d'une virgule.
'Equivalent a (?<![\,])[\,](?![\,]) soit (pas de virgule avant, pas de virgule après), mais non supporter par vb (test arrière (?<!....).
 
'(\?)|(\!)|(\:)|(\;)|(\,)|(\')|(\&)|(\~)|(\{)|(\})|(\()|(\))|(\[)|(\])|(\@)|(\^)|(\¨)|(\$)|(\£)|(\€)|(\.)|(\<)|(\>)|(\|)
 
'"\" =([^\\]|^)([\\])(?![\\])		'"&" =([^\&]|^)([\&])(?![\&])		"£" =([^\£]|^)([\£])(?![\£])		
'"/" =([^\/]|^)([\/])(?![\/])		'"~" =([^\~]|^)([\~])(?![\~])		"€" =([^\€]|^)([\€])(?![\€])		
'"*" =([^\*]|^)([\*])(?![\*])		'"{" =([^\{]|^)([\{])(?![\{])		"." =([^\.]|^)([\.])(?![\.])		
'"+" =([^\+]|^)([\+])(?![\+])		'"}" =([^\}]|^)([\}])(?![\}])		"<" =([^\<]|^)([\<])(?![\<])		
'"-" =([^\-]|^)([\-])(?![\-])		'"(" =([^\(]|^)([\(])(?![\(])		">" =([^\>]|^)([\>])(?![\>])		
'"=" =([^\=]|^)([\=])(?![\=])		'")" =([^\)]|^)([\)])(?![\)])		"|" =([^\|]|^)([\|])(?![\|])		
'"?" =([^\?]|^)([\?])(?![\?])		'"[" =([^\[]|^)([\[])(?![\[])		
'"!" =([^\!]|^)([\!])(?![\!])		'"]" =([^\]]|^)([\]])(?![\]])		
'":" =([^\:]|^)([\:])(?![\:])		'"@" =([^\@]|^)([\@])(?![\@])		
'";" =([^\;]|^)([\;])(?![\;])		'"^" =([^\^]|^)([\^])(?![\^])		
'"," =([^\,]|^)([\,])(?![\,])		'"¨" =([^\¨]|^)([\¨])(?![\¨])		
'"'" =([^\']|^)([\'])(?![\'])		'"$" =([^\$]|^)([\$])(?![\$])		
 
'							Char		 |			char				|		char 
FindSpeciChars = "([^\\]|^)([\\])(?![\\])|([^\/]|^)([\/])(?![\/])|([^\*]|^)([\*])(?![\*])" _
			  & "|([^\-]|^)([\-])(?![\-])"
 
 strText = TxtSource  
 Set RegularExpressioN = New RegExp
 RegularExpressioN.Pattern = FindSpeciChars
 RegularExpressioN.Global = True
 Set Matches = RegularExpressioN.Execute(strText)
 	If Matches.Count > 0 Then    
		MatchMsg = Matches.Count & " correspondance(s) trouvée(s)." & vbCRLF
			For Each Match In Matches
				For i = 1 To match.SubMatches.Count - 1 Step 2
					If Not (match.SubMatches(i) = "") Then
                		MatchMsg = MatchMsg & "Correspondance trouvée """ & match.Submatches(i) & """ en position: " & match.FirstIndex + Len(match.Value) - 1 & vbCrLf 
        		Next     
			Next
      			'MsgBox MatchMsg
			Else
      			MsgBox "Aucun match", 0, "VBScript RegExp Tester"
	End If              
 strText = RegularExpressioN.Replace(strText, "($&)") 'Parenthèses pour aider à la localisation des caractères remplacés.
 Set RegularExpressioN = Nothing
 ReslutSpeciChars = strText
 
MsgBox TxtSource & vbCrLf & ReslutSpeciChars & vbCrLf & MatchMsg

[NeriXs]

Ce genre de pattern "([\\\*/-])(?<!\1\1)(?!\1)" solutionnerait mon problème, mais encore une fois le fameux test arrière non supporté pas VBScript.
une alternative est elle possible*?

[CosmoKnacki]

J’espère que ce que j’essaie de faire est réalisable?

Tout le problème est là, personne ne serait capable de dire ce que tu cherches à faire. Ça serait une bonne chose d'expliquer où tu veux en venir. (Typiquement avec une chaîne en entrée et le résultat espéré en sortie).

...si deux caractères isolés sont côte à côte...

S'il sont côte à côte, ils ne sont pas si isolé que ça. Là encore, on sombre dans les sables mouvants du pas très clair.

[NeriXs]

Le bute est pour chaque caractère spéciaux lors qu’ils ne font pas partie d’un groupe de caractères identiques la récupération de la valeur et de la position et le remplacement par lui-même.

Quand je parle des caractères côte à côte c'est dans le cas ou ceux-ci ne sont pas identiques.

Exemple dans la chaîne suivante: \\?\???
Les caractères du pattern: \|?
j’ai bien un \ isolé et un ? Isolé aussi, mais comme ils sont côte a côte seule le ? Est reconnue car pour le \ mon caractère précédent est déjà consommé, il a une sorte de chevauchement.

[CosmoKnacki]

Mouais, on est pas plus renseigner sur la raison du remplacement d'un caractère par lui même.

Toujours est-il que pour arriver à tes fins, tu peux consommer ce qui ne t'intéresse pas en le plaçant dans un groupe de capture pour pouvoir l'identifier en le faisant suivre d'un autre groupe de capture pour le caractère isolé. Mais attention, celui-ci devra être optionnel, car rien ne prouve que par exemple ** soit suivi d'un des caractères recherchés isolé.

Donc j'utiliserai cette pattern:((?:([!$&-/:-@\[-^{-~£€¨])\2+)*)([!$&-/:-@\[-^{-~£€¨]?).

En détail:

Code php :

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

1
2
3
4
5
6
7
8
9
(    # groupe de capture 1: récupère les éventuels caractères répétés
    (?: # groupe non-capturant
        ([!$&-/:-@\[-^{-~£€¨]) # groupe de capture 2: capture un des caractères
        \2+            # uniquement quand celui-ci est répété
    )* # répète ce groupe zéro ou n fois de manière gourmande (greedy): c à d autant de fois que possible
) # ferme le groupe de capture 1
( # groupe de capture 3: qui contient soit le caractère isolé, soit rien
[!$&-/:-@\[-^{-~£€¨]?
)

À noter que [!$&-/:-@\[-^{-~£€¨] est une classe de caractères contenant tous les caractères présents dans ton alternative de départ. Pour que ce soit plus court à écrire, il suffit d'utiliser des rangs de caractères comme &-/ (au même titre que a-z ou 0-9, voir la table iso-8859-1).

Bien entendu, avec cette pattern tu devras modifier ton code:

• Pour vérifier que le groupe 3 n'est pas vide avant d'afficher les résultats du match
• Pour déterminer la position du groupe 3 en additionnant la position du groupe 1 à sa taille
• Placer une référence au groupe 1 dans ta chaîne de remplacement

NB: l'échappement devant [ dans une classe de caractère n'est peut-être pas utile (à tester).


Si le fait que le groupe de capture 3 peut être éventuellement vide pose problème (pour par exemple placer des parenthèses autour du caractère), deux solutions sont envisageables:

• Modifier la pattern pour qu'elle consomme tous les caractères de la chaîne sans exception et utiliser des groupes de capture pour savoir ce qui est le caractère isolé et ce qui ne l'est pas, puis ne pas utiliser la méthode replace et reconstruire la chaîne avec les différents matches.
• Utiliser cette fonctionnalité de Javascript émulée pour vbs qui permet d'utiliser une fonction de rappel à la place d'une chaîne de remplacement: voir ici

[NeriXs]

Bonjour,
la raison de cette démarche est que je dois par la suite replacer ces caractères (après d’autre traitements) dans la chaîne source a leurs position d’origine.

Je pense avoir compris dans les grandes lignes de ce que tu propose.
Donc:
Le groupe 1 => Récup caractères contenant au minimum 2 occurrences d’un même caractère.
Le groupe 2 => Récup caractères isolés non unique.
Le groupe 3 => Conteneur liste caractères.

Pour les modifications du code:
1) vérifier que le groupe 3 n'est pas vide

Code :

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

If match.Submatches(3) <> "" Then

2) déterminer la position du groupe 3 en additionnant la position du groupe 1 à sa taille.

Code :

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

match.FirstIndex + Len(match.SubMatches(1))

3) Placer une référence au groupe 1 dans ta chaîne de remplacement

Code :

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

strText = RegularExpressioN.Replace(strText, "$1")

je n’ai pas compris ton explication concernant le groupe de capture pour les caractères isolés et le fait qu’il doit être optionnel?

Quoi qu’il en soit si un développeur expérimenté (CosmoKnacki je sais que tu ne travail pas sous Windows, donc difficile de tester) pouvait me donner un exemple concret, car là j’ai du mal a me projeter.
La faculté d’analyse et de projection que vous avez est encore loin de m’être acquise.

[NeriXs]

Mes valeurs et positions semblent bonnes.

Code :

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

If match.Submatches(3) <> "" Then

Me remonte une erreur :

Error :Argument ou appel de procédure incorrect
Code :800A0005
Source : Erreur d’exécution Microsoft VBScript
System : Accès refusé.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
TxtSource = "\-\\\*-****/Un test, Pourquoi faire? c'est fou ça! \****-*/// /" 
ReslutSpeciChars = "" 
 
Dim strText, RegularExpressioN
 
FindSpeciChars = "((?:([!$&-/:-@\[-^{-~£€¨])\2+)*)([!$&-/:-@\[-^{-~£€¨]?)"
 
 strText = TxtSource  
 Set RegularExpressioN = New RegExp
 RegularExpressioN.Pattern = FindSpeciChars
 RegularExpressioN.Global = True
 Set Matches = RegularExpressioN.Execute(strText)
 	If Matches.Count > 0 Then    
		MatchMsg = Matches.Count & " correspondance(s) trouvée(s)." & vbCRLF
			For Each Match In Matches
					If match.Submatches(3) <> "" Then
                		MatchMsg = MatchMsg & "Correspondance trouvée """ & match.Submatches(2) & """ en position: " & match.FirstIndex + Len(match.SubMatches(1)) & vbCrLf      
					End If
			Next
      			'MsgBox MatchMsg
			Else
      			MsgBox "Aucun match", 0, "VBScript RegExp Tester"
	End If              
 strText = RegularExpressioN.Replace(strText, "($1)") 'Parenthèses pour aider à la localisation des caractères remplacés.
 Set RegularExpressioN = Nothing
 ReslutSpeciChars = strText
 
MsgBox TxtSource & vbCrLf & ReslutSpeciChars & vbCrLf & MatchMsg

[CosmoKnacki]

Le contenu du groupe 3 doit être optionnel pour une raison précise: imagine que tu as la chaîne @ abc **& def :: et que le contenu du groupe 3 ne soit pas optionnel, donc ((?:([!$&-/:-@\[-^{-~£€¨])\2+)*)([!$&-/:-@\[-^{-~£€¨]). Voyons ce qui se passe:

position	match	groupe_1	groupe_2	groupe_3	commentaire
0	@	Vide	Vide	@
6	**&	**	*	&
14	Échec	::	:	Échec	Il n'y a pas de correspondance à cette position car le groupe 3 échoue. Ce qui fait que le moteur de regex va tester la position suivante!
15	:	Vide	Vide	:	On obtient alors ce résultat non voulu.

On voit bien que si la pattern échoue à la position 14 (au premier :), les deux :: ne seront alors pas consommés dans le groupe 1. Par contre, comme le moteur de regex va tester la pattern à la position suivante (au deuxième :), la pattern va réussir en plaçant ce : dans le groupe 3. Dans ce cas la pattern ne joue plus son rôle consistant à placer les caractères répétés dans le groupe 1 et les autres dans le groupe 3.

Si par contre le contenu du groupe 3 est optionnel: ((?:([!$&-/:-@\[-^{-~£€¨])\2+)*)([!$&-/:-@\[-^{-~£€¨]?):

position	match	groupe_1	groupe_2	groupe_3	commentaire
0	@	Vide	Vide	@
6	**&	**	*	&
14	::	::	:	Vide	J'obtiens un match. Certes, il n'y a pas de caractère isolé, mais il suffit de tester le groupe 3 pour le savoir et j'ai consommé les deux ::. La pattern ne sera donc pas testée à la position 15, je ne risque donc plus de récupérer le dernier : avec le groupe 3.

[CosmoKnacki]

Pour ce qui est de l'erreur que ton code t'affiche, sans trop m'avancer je pense qu'il s'agit d'un problème de numérotation des groupes. Je me cite d'un post précédent:

(car bien entendu le groupe de capture 2 est stocké dans le "submatch" 1, de même que le groupe de capture 1 est stocké dans le "submatch" 0. Si quelqu'un connait le responsable de cette ânerie qu'il n'hésite pas à le gifler de ma part.)

Donc pour tester le groupe de capture 3:

Code :

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

If match.Submatches(2) <> "" Then

[NeriXs]

Merci pour ces explications c'est beaucoup plus claire maintenant.
Pour rendre le contenue d'un groupe optionnel on utilise le "?" juste avant la parenthèse de fermeture du groupe c'est bien ça?

Si le fait que le groupe de capture 3 peut être éventuellement vide pose problème (pour par exemple placer des parenthèses autour du caractère), deux solutions sont envisageables:

• Modifier la pattern pour qu'elle consomme tous les caractères de la chaîne sans exception et utiliser des groupes de capture pour savoir ce qui est le caractère isolé et ce qui ne l'est pas, puis ne pas utiliser la méthode replace et reconstruire la chaîne avec les différents matches.
• Utiliser cette fonctionnalité de Javascript émulée pour vbs qui permet d'utiliser une fonction de rappel à la place d'une chaîne de remplacement: voir ici

ici aussi j’aurais besoin d'explications

[CosmoKnacki]

Pour rendre n'importe quoi optionnel on utilise le quantificateur ?: cette information tu la trouveras dans n'importe quel tutoriel sur les regex.

Pour ce qui est de la première idée, elle consiste à créer une pattern qui va toujours réussir, sous la forme:(ce que je ne veux pas)|(ce que je veux). Une fois encore, les groupes de capture te permettent de savoir ce que tu viens de chopper. Avec une telle pattern et quelques tests il est facile de construire ta chaîne résultat. Je te laisse le soin de te pencher sur son écriture.

[NeriXs]

OK je regarde ça dés que possible ! Merci.
Dans l’immédiat j’ai un problème de position sur 3 caractères.
Voici ce que j’ai, la bonne valeur a été ajoutée après les =>

Correspondance trouvée "\" en position: 0
Correspondance trouvée "-" en position: 1
Correspondance trouvée "*" en position: 3 => 5
Correspondance trouvée "-" en position: 6
Correspondance trouvée "/" en position: 8 => 11
Correspondance trouvée "," en position: 19
Correspondance trouvée "?" en position: 35
Correspondance trouvée "'" en position: 38
Correspondance trouvée "!" en position: 49
Correspondance trouvée "\" en position: 51
Correspondance trouvée "-" en position: 53 => 56
Correspondance trouvée "*" en position: 57
Correspondance trouvée "/" en position: 62

[CosmoKnacki]

C'est normal, pour chaque position tu dois ajouter la taille du groupe 1. Si tu n'obtiens pas le bon résultat quand ton caractère est précédé de caractères répétés c'est que quelque chose cloche dans le calcule de cette taille. À toi de trouver.

[NeriXs]

Code :

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

match.FirstIndex + Len(match.SubMatches(0))

au lieu de

Code :

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

match.FirstIndex + Len(match.SubMatches(1))

Arf désolé je vais pas mis faire a cette annerie.
comme tu l'as dit il y a des gifles qui se perdent.

[CosmoKnacki]

C'est clair, dans pratiquement tous les langages le 0 c'est pour le match complet, le 1 pour le groupe 1, le 2 pour le groupe 2, etc.

[NeriXs]

je suis un
Désolé je ne me projet pas sur le problème du groupe de capture 3 éventuellement vide.
Placer des parenthèses autour d'un caractère c’est 3 caractères isolés non ?

[CosmoKnacki]

C'est ce qui coince avec la pattern originale, car si le groupe 3 est vide et que tu veux mettre des parenthèses autour du caractère isolé, tu risques de te retrouver avec des parenthèses autour de rien. C'est pour ça que j'ai fait deux autres suggestions. La première que j'ai décrite précédemment (reconstruction de la chaîne en s'aidant d'une pattern qui matche tous les caractères mais permet de faire le tri) et la deuxième qui émule une possibilité qu'offre javascript et qui consiste à utiliser une fonction à la place d'une chaîne de remplacement. (l'intérêt d'avoir une fonction, c'est que tu peux dans la fonction tester si un groupe de capture est vide pour choisir quel va être le remplacement.)

[NeriXs]

La ou je bloque, c’est que je ne voix pas dans quel cas de figure le groupe3 pourrait être vide ?

Je viens de relire le poste #9, j'ai compris je reviens en fin de matinée.

[NeriXs]

Bon je me lance :
Pour le pattern voila comment je l’ai imaginé :
Ce que je veux : les caractères isolés.
Ce que je ne veux pas, les caractères identiques de 2 occurrences ou plus.

Code :

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

((?:([!$&-/:-@\[-^{-~£€¨]|^[!$&-/:-@\[-^{-~£€¨]){2,})*)([!$&-/:-@\[-^{-~£€¨]?)

Donc 3 groupes (groupe 0, groupe 1 et groupe 2)
Mais jamais rien dans le groupe 3!