syntaxe expression reguliere dans RegEx.replace

Version imprimable

09/09/2009, 22h26
guich77

syntaxe expression reguliere dans RegEx.replace

Bonjour à tous,

Je vous sollicite car j'aurai besoin d'un coup de main pour monter une expression régulière afin de remplacer des caractères.

Contexte :
j'ai une donnée de type String, dont le format "connu de l'humain" est 10 lettres suivi de 5 chiffres.
Soucis majeur : je me retrouve avec des 1 à la place des I dans les 10 premiers caractères, et inversement des I à la place des 1 dans les 5 derniers.

J'utilise l'expression régulière suivante pour tester si c'est OK ou non :
If Regex.IsMatch(MaChaine, "(^[A-Z]{10}[1-9]{5}$)")
et ça a plutot l'air de coller.

Par contre, je souhaiterai passer également par le Regex.Replace pour remplacer automatiquement les I par des 1 et inversement.

Je pourrais bien le faire avec des String.Replace ou en mettant du MaChaine.Substring ... dans le Regex.Replace mais je souhaiterai un truc propre et direct en 1 instruction ...... et je galère à trouver la bonne syntaxe.

Donc si quelqu'un a une idée : je suis preneur

D'avance merci à ceux qui se pencheront sur le problème
Guich

Essaye avec

Code:

1
2
3
4
5
6
7
8
9
string maChaine = "AIC1EFGH1JI2145";
if (Regex.IsMatch(maChaine, "^[A-Z1]{10}[1-9I]{5}$"))
{
    maChaine = Regex.Replace(maChaine, @"1(?=.{5,})|(?<=.{10,})I",
               delegate(Match m)
               {
                   return (m.Value == "1") ? "I" : "1";
               });
}

Cela devrait donner le résultat souhaité.

10/09/2009, 12h01
guich77

Bonjour StormimOn,

j'ai essayé le code que tu m'as donné et je confirme que ça fonctionne à merveille (en tout cas avec le peu de tests que j'ai pu faire).

Par contre, si tu pouvais m'expliquer le fonctionnement (et notamment la syntaxe et le delegate) car j'aimerais pouvoir l'adapter et j'aime pas le faire betement ...

En tout cas merci bien
Guich
10/09/2009, 13h29
StormimOn

Citation:

Envoyé par guich77

Par contre, si tu pouvais m'expliquer le fonctionnement (et notamment la syntaxe et le delegate)

Bien sûr. Je n'ai pas eu le temps de détailler quand j'ai répondu, mais je comptais compléter :)

La partie simple : ^[A-Z1]{10}[1-9I]{5}$

Cette expression va permettre de voir si la chaîne correspond à ce que l'on attend, en tenant compte du fait que l'on peut avoir des 1 à la place des I dans les 10 premiers caractères, et des I à la place des 1 dans les 5 suivants.

La partie compliquée : 1(?=.{5,})|(?<=.{10,})I

L'expression 1(?=.{5,}) va permettre de récupérer tous les 1 suivis par au moins 5 caractères. On va ainsi obtenir les 1 qui se trouvent dans les 10 premiers caractères.

L'expression (?<=.{10,})I va permettre d'obtenir tous les I précédés par au moins 10 caractères. On va ainsi obtenir les I qui se trouvent dans les 5 derniers caractères.

On combine ces 2 expressions avec l'opérateur OU (caractère pipe, |) pour avoir l'ensemble des 1 et des I qui doivent donc être remplacés.

Après on utilise le MatchEvaluator pour gérer le remplacement. Il faut indiquer une méthode prenant un objet de type Match en paramètre et renvoyant un string, afin de correspondre au prototype de la délégation. J'utilise ici ce que l'on appelle une méthode anonyme (la syntaxe avec le delegate), mais on peut faire avec une méthode nommée. L'idée c'est que si la correspondance renvoi un 1 alors il faut mettre un I à la place et inversement.

En espérant que cela soit plus clair après ça ;)

Impec, ça c'est de l'explication !!!

Du coup, j'ai pu généraliser aux autres cas ambigus avec le code suivant :

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
 
            if (Regex.IsMatch(MaChaine, "^[A-Z12580]{10}[0-9IZSBO]{5}$"))
            {
                MaChaine = Regex.Replace(MaChaine, @"[12580](?=.{5,})|(?<=.{10,})[IZSBO]",
                           delegate(Match m)
                           {
                               switch (m.Value.ToString())
                               {
                                   case "1":
                                       return "I";
 
                                   case "I":
                                       return "1";
 
                                   case "2":
                                       return "Z";
 
                                   case "Z":
                                       return "2";
 
                                   case "5":
                                       return "S";
 
                                   case "S":
                                       return "5";
 
                                   case "8":
                                       return "B";
 
                                   case "B":
                                       return "8";
 
                                   case "0":
                                       return "O";
 
                                   case "O":
                                       return "0";
 
                                   default:
                                       return m.Value.ToString();
                               }
                           });
            }

et ça corrige très bien l'ensemble de ma chaine à la volée

Merci pour tout
Guich