RegExp récupérer Submatches ?

Version imprimable

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:

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

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:

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

15/12/2017, 19h17
Invité

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*?
15/12/2017, 23h47
CosmoKnacki

Citation:

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).

Citation:

...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.
15/12/2017, 23h57
Invité

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.

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:

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

16/12/2017, 10h20
Invité

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:

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

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

Code:

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

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

Code:

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.

Mes valeurs et positions semblent bonnes.

Code:

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:

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

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.

16/12/2017, 20h40
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:

Citation:

(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:

If match.Submatches(2) <> "" Then
16/12/2017, 21h20
Invité
Merci pour ces explications c'est beaucoup plus claire maintenant. :king:
Pour rendre le contenue d'un groupe optionnel on utilise le "?" juste avant la parenthèse de fermeture du groupe c'est bien ça?
Citation:
Envoyé par CosmoKnacki

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 :pastaper:
16/12/2017, 22h05
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.
16/12/2017, 22h13
Invité

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
16/12/2017, 22h26
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.
16/12/2017, 22h41
Invité

Code:

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

au lieu de

Code:

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.
16/12/2017, 22h47
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.
16/12/2017, 23h09
Invité

je suis un :boulet: :boulet: :boulet:
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 ?
16/12/2017, 23h41
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.)
16/12/2017, 23h48
Invité

~~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.
17/12/2017, 09h46
Invité

Bon je me lance : :calim2:
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:

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

Donc 3 groupes (groupe 0, groupe 1 et groupe 2) :scarymov:
Mais jamais rien dans le groupe 3! :koi: :mur:
17/12/2017, 10h07
Invité

2 éme tentative

Code:

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

Cette fois 4 groupes !
Toujours pas bon ! ma salade est prête pour ce midi ! :cry:

Je suis en train de tous mélanger dans ma petite tête . :marteau:

En parallèle dans un bute purement éducatif, si quelqu’un avait un peu de temps et l’envie de jouer avec cette fonctionnalité de Javascript!
J’aurais bien aimé voir ce que ça donne.
Je ne me sens pas encore capable de le mettre en place.

Lien : http://cwestblog.com/2011/07/18/vbsc...back-function/

Code de base :

Code:

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
54
55
56
57
58
59
60
61
62
63
64
<html>
<head>
<title>My HTML application</title>
<HTA:APPLICATION
  APPLICATIONNAME="My HTML application"
  ID="MyHTMLapplication"
  VERSION="1.0"/>
</head>
 
<script language="VBScript">
 
Option Explicit
 
Dim FindSpaciChars
Dim strText , RegularExpressioN 
Dim matches, MatchMsg, match
 
FindSpaciChars = "((?:([!$&-/:-@\[-^{-~£€¨])\2+)*)([!$&-/:-@\[-^{-~£€¨]?)"
 
	Sub JobSpaciChars 	
		strText = TxtSource.Value		
		Set RegularExpressioN = New RegExp
		RegularExpressioN.Pattern = FindSpaciChars
		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 Not (match.SubMatches(2) = "") Then
                			MatchMsg = MatchMsg & "Correspondance trouvée """ & match.Submatches(2) & """ en position: " & match.FirstIndex + Len(match.SubMatches(0)) & vbCrLf        
						End If
		    		Next
		    	TxtMatchesSpaciChars.Value =  MatchMsg
		  	Else
		    	MsgBox "No match", 0, "VBScript Regular Expression Tester"
		  	End If		  										
		strText = RegularExpressioN.Replace(strText, "$1$3")
		Set RegularExpressioN = Nothing
		TxtReslutSpaciChars.Value = strText		 
	End Sub	
 
</script>
 
<body bgcolor="white">
 
</body>			    	
    	<!-- LABEL TxtSource  -->
		<label for="LabSource">Saisir le texte à traiter:</label></P>
		<!-- TEXTBOX TxtSource -->
    	<TEXTAREA type="text" name="TxtSource" Value ="" style="height:55px; width:500px">\-\\\*-****/Un test, Pourquoi faire? c'est fou ça! \****-*/// /</TEXTAREA></P>    	
 
    	<!-- BUTTON JobSpaciChars -->
    	<input type="button" value="Traitement des caractères minuscules isolés." onClick="JobSpaciChars" style="height:35px; width:500px"></P>
 
    	<!-- TEXTBOX TxtMatchesSpaciChars -->
    	<TEXTAREA type="text" name="TxtMatchesSpaciChars" Value ="" style="height:75px; width:500px"></TEXTAREA></P>
 
    	<!-- LABEL LabResultCharsMinChars -->
    	<label style="height:15px; width:500px" for="LabResultCharsMinChars">Caractères  de la "Phase 1" remplacés:</label></P>
 
    	<!-- TEXTBOX TxtReslutSpaciChars -->
    	<TEXTAREA type="text" name="TxtReslutSpaciChars" Value ="" style="height:75px; width:500px"></TEXTAREA>
 
</html>

Pour mémo:
Ce qui coince avec la pattern originale, c'est que 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.
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.)

18/12/2017, 23h19
Invité

Bonjour,
J’ai beau tourner la chose dans tous les sens, je ne voix pas dans quel cas de figure le groupe 3 pourrait être vide vu qu’on a l'a rendu optionnel?
Pourrais-je avoir un exemple concret?

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.