Discussion :

[Yonito]

Salut tous le monde,

je rencontre un petit souci pour extraire des donnees d'une expression reguliere. La voici :

([0-9]{9})\s*(E[0-9]+.*?)-((.*?)-([0-9]+.[0-9]{1,2})|.*)

Cette expression me permet d'extraire les informations sur ce genre de phrase :

700012839 E703 -DOMAINE PREST NON OUVERT PAR L AMC
000001708 E0480 0051- NUAT. (DRE) 0.00-0.00
000279001 E0317 0511 - INCOMPATIBILITE ASU-NAT / REGIME 0.00-1.00

Le premier groupe me recupere les 9 premiers caracteres numeriques.
Le second groupe, le code a partir de E jusqu'au trait -

Le troisieme groupe utilise l'operateur OR : ((.*?)-([0-9]+.[0-9]{1,2})|.*)
Mon souci est que je ne veux recuperer soit le groupe (.*?) que j'appelerai groupe A ET ([0-9]+.[0-9]{1,2}, groupe B, OU uniquement .*, groupe C
or la les parentheses externes me renvoi un groupe comprenant le groupe A et le groupe B ensemble. (en plus des groupes A et B separés)

A titre d'exemple pour etre claire.
Input : 000001708 E0480 0051-NUAT. (DRE) 0.00-0.00

je recupere :
groupe 1 = 000001708
groupe 2 = E0480 0051
groupe 3 = NUAT. (DRE) 0.00-0.00
groupe 4 = NUAT. (DRE) 0.00
groupe 5 = 0.00

Mon but est de ne pas recuperer le groupe 3 qui reprend enfaite le groupe 4 et 5 ensemble.

j'espere avoir ete claire.

PS : je debute en regex donc mon expression n'est surement pas la meilleure.

merci

[tchize_]

En gros, tu veux récupérer

groupe 1 = 000001708
groupe 2 = E0480 0051
groupe 3 = NUAT. (DRE) 0.00
groupe 4 = 0.00

?

Dans ce cas, ceci devrait faire l'affaire (non capturing group)

Code :

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

([0-9]{9})\s*(E[0-9]+.*?)-(?:(.*?)-([0-9]+.[0-9]{1,2})|.*)

[CosmoKnacki]

Au lieu d'utiliser un opérateur OR, tu peux tout simplement rendre le dernier groupe (et son tiret) optionel, en écrivant (?:-([0-9]+\.[0-9]{1,2}))?.

Maintenant, afin d'obtenir une expression robuste et rapide, il faut être le plus explicite possible en évitant d'utiliser des .*? ou des .* qui sont beaucoup trop permissifs (aucune contrainte de caractères, mise à part une nouvelle ligne, aucune contrainte de taille, ni même d'existence), et qui peuvent demander un travail considérable au moteur de regex si la correspondance n'est pas évidente (car dans ce cas le moteur de regex va ajouter ou retirer des caractères à ces sous-patterns pour essayer d'autre possibilités d'obtenir une correspondance).

Donc l'idéal est de fournir un véritable couloir au moteur de regex de manière à ce qu'il ait le moins possible de questions à se poser.

Je suppose que chacune des phrases que tu as données en exemple correspond à une ligne complète. (Si ce n'est pas le cas, n'hésites pas à le dire.)

Pour exploiter le fait qu'une phrase occupe toute une ligne on va utiliser les ancres ^ et $. Par défaut, ces ancres marquent le début et la fin d'une chaîne, mais si on utilise le modificateur (?m), alors ces ancres marquent le début et la fin d'une ligne. Ça n'a l'air de rien comme ça, mais ça réduit de beaucoup le travail, notamment en évitant de chercher une correspondance ailleurs qu'au début d'une ligne.

Il faut remplacer maintenant les .*? par quelque chose de plus explicite.

Pour le deuxième groupe (E[0-9]+.*?) c'est assez facile car, d'après les exemples, on sait qu'il peut y avoir un espace suivi d'autres chiffres. On peut donc le réécrire comme ça: (E[0-9]+(?: [0-9]+)?). On place l'espace et les autres chiffres dans un groupe non-capturant (?:...) que l'on rend optionnel avec le quantificateur ?.

C'est un peu plus difficile de remplacer le 3e groupe (.*?). Ici, on va exploiter le fait que celui-ci se termine soit avant le tiret et le nombre décimal (quand ils sont présents), soit à la fin de la ligne.
La solution est d'utiliser la classe de caractères [^-\n] qui autorise tous les caractères sauf les tirets et les nouvelles lignes (ça évite de déborder sur les lignes suivantes). Ça fonctionne très bien avec les deux premiers exemples, par contre ça ne marche pas avec le troisième qui contient justement un tiret. Ce n'est pas grave, il suffit d'autoriser les tirets pour cette partie en écrivant ([^-\n]+(?:-[^-\n]+)*) (C'est exactement le même principe que pour le groupe 2 avec les chiffres et l'espace, sauf qu'on autorise plusieurs répétitions).
Mais il y a de nouveau un problème car les quantificateurs étant gourmands par défaut, la sous-pattern (?:-[^-\n]+)* va écrabouiller le dernier groupe optionel (?:-([0-9]+\.[0-9]{1,2}))?. Il faut donc utiliser un quantificateur non-gourmand: ([^-\n]+(?:-[^-\n]+)*?) ce qui fait qu'à chaque tiret rencontré le dernier groupe est testé en premier avant de répéter (?:-[^-\n]+).

Code :

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

(?m)^([0-9]{9})\s+(E[0-9]+(?: [0-9]+)?)\s*-\s*([^-\n]+(?:-[^-\n]+)*?)(?>-([0-9]+\.[0-9]{1,2}))?$

[Yonito]

En gros, tu veux récupérer

groupe 1 = 000001708
groupe 2 = E0480 0051
groupe 3 = NUAT. (DRE) 0.00
groupe 4 = 0.00

?

Dans ce cas, ceci devrait faire l'affaire (non capturing group)

Code :

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

([0-9]{9})\s*(E[0-9]+.*?)-(?:(.*?)-([0-9]+.[0-9]{1,2})|.*)

Merci de ta reponse, je l'avais deja essayé auparavant, maheuresement elle ne fonctionne pas pour des patterns de ce style :

700012839 E703 -DOMAINE PREST NON OUVERT PAR L AMC

Le libellé DOMAINE..... n'est pas recupéré.

Merci quand meme

[Yonito]

Au lieu d'utiliser un opérateur OR, tu peux tout simplement rendre le dernier groupe (et son tiret) optionel, en écrivant (?:-([0-9]+\.[0-9]{1,2}))?.

Maintenant, afin d'obtenir une expression robuste et rapide, il faut être le plus explicite possible en évitant d'utiliser des .*? ou des .* qui sont beaucoup trop permissifs (aucune contrainte de caractères, mise à part une nouvelle ligne, aucune contrainte de taille, ni même d'existence), et qui peuvent demander un travail considérable au moteur de regex si la correspondance n'est pas évidente (car dans ce cas le moteur de regex va ajouter ou retirer des caractères à ces sous-patterns pour essayer d'autre possibilités d'obtenir une correspondance).

Donc l'idéal est de fournir un véritable couloir au moteur de regex de manière à ce qu'il ait le moins possible de questions à se poser.

Je suppose que chacune des phrases que tu as données en exemple correspond à une ligne complète. (Si ce n'est pas le cas, n'hésites pas à le dire.)

Pour exploiter le fait qu'une phrase occupe toute une ligne on va utiliser les ancres ^ et $. Par défaut, ces ancres marquent le début et la fin d'une chaîne, mais si on utilise le modificateur (?m), alors ces ancres marquent le début et la fin d'une ligne. Ça n'a l'air de rien comme ça, mais ça réduit de beaucoup le travail, notamment en évitant de chercher une correspondance ailleurs qu'au début d'une ligne.

Il faut remplacer maintenant les .*? par quelque chose de plus explicite.

Pour le deuxième groupe (E[0-9]+.*?) c'est assez facile car, d'après les exemples, on sait qu'il peut y avoir un espace suivi d'autres chiffres. On peut donc le réécrire comme ça: (E[0-9]+(?: [0-9]+)?). On place l'espace et les autres chiffres dans un groupe non-capturant (?:...) que l'on rend optionnel avec le quantificateur ?.

C'est un peu plus difficile de remplacer le 3e groupe (.*?). Ici, on va exploiter le fait que celui-ci se termine soit avant le tiret et le nombre décimal (quand ils sont présents), soit à la fin de la ligne.
La solution est d'utiliser la classe de caractères [^-\n] qui autorise tous les caractères sauf les tirets et les nouvelles lignes (ça évite de déborder sur les lignes suivantes). Ça fonctionne très bien avec les deux premiers exemples, par contre ça ne marche pas avec le troisième qui contient justement un tiret. Ce n'est pas grave, il suffit d'autoriser les tirets pour cette partie en écrivant ([^-\n]+(?:-[^-\n]+)*) (C'est exactement le même principe que pour le groupe 2 avec les chiffres et l'espace, sauf qu'on autorise plusieurs répétitions).
Mais il y a de nouveau un problème car les quantificateurs étant gourmands par défaut, la sous-pattern (?:-[^-\n]+)* va écrabouiller le dernier groupe optionel (?:-([0-9]+\.[0-9]{1,2}))?. Il faut donc utiliser un quantificateur non-gourmand: ([^-\n]+(?:-[^-\n]+)*?) ce qui fait qu'à chaque tiret rencontré le dernier groupe est testé en premier avant de répéter (?:-[^-\n]+).

Code :

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

(?m)^([0-9]{9})\s+(E[0-9]+(?: [0-9]+)?)\s*-\s*([^-\n]+(?:-[^-\n]+)*?)(?>-([0-9]+\.[0-9]{1,2}))?$

Merci de ta reponse detaillée elle va me permettre de comprendre mieux comment ecrire une expression cependant, je l'ai testé sur un site de regex, je ne sais pas si on a le droit de citer des sites web et cela ne fonctionne pas.
Lorsque j'ai ecrit les exemples, les espaces "en trop" sont supprimés aparament donc voici un imprim ecran des exemples possibles :



Sur l'image, on peut voir qu'il peut y avoir beaucoup d'espace entre chaque thermes. J'ai bien essayé de rajouter \s* pour considerer les espaces mais cela ne me renvoi aucune correspondance.


Que veut dire le signe > dans ton expression ?


merci

[tchize_]

Merci de ta reponse, je l'avais deja essayé auparavant, maheuresement elle ne fonctionne pas pour des patterns de ce style :

700012839 E703 -DOMAINE PREST NON OUVERT PAR L AMC

En même temps, tu nous a montré un regexp d'origine qui nécessite 2 tirets, pas un seul. Tu pourrais
1) nous montrer schématiquement comment tu veux découper (par exemple avec des exemple de textes et de résultats que tu veux) parce que ce n'est pas claire our moi
2) nous expliquer pourquoi tu as absolument besoin d'utiliser desregexp pour décomposer ces lignes tordues? Je ne suis pas sur que ce soit le meilleur moyen de faire, en tout cas le plus lisible pour celui qui devra maintenir ton code par la suite, ni le plus performant.

[CosmoKnacki]

En fait si ça marche très bien. Ce qu'il faut savoir c'est que tous les langages n'ont pas le même support des regex, un tel aura une fonctionnalité, un autre ne l'aura pas, et d'autre part les testeurs online n'implémentent pas toujours toutes les fonctionnalités même pour un langage précis (c'est le cas d'une très grosse partie des testeurs online, même chez les plus populaires).

Pour ce qui est de http://regexr.com/ c'est un testeur pour Javascript qui a assez peu de fonctionnalités en comparaison avec des langages comme Java, PHP, Ruby, Perl, .net...

Donc le seul test irréfutable, c'est celui que l'on a fait dans son code.

Cela dit, tu peux voir la pattern fonctionner sur regexplanet.com (clique sur le bouton "Java") ou sur regex101.com (qui lui est plutôt un testeur pour PHP/PCRE mais les fonctionnalités utilisées dans la pattern sont communes aux deux langages)

Pour ce qui est du groupe atomique (?>...) c'est comme un groupe non-capturant, sauf qu'une fois la parenthèse fermée, le moteur de regex n'aura plus le droit de reculer caractère par caractère pour tester d'autres éventualités (dans le cas où la pattern échouerait plus tard) parmi les caractères correspondant au groupe atomique, mais devra directement reculer à la position avant le groupe atomique (atome = que l'on ne peut pas diviser). C'est une petite optimisation que j'ai ajoutée si par hasard le groupe 3 devait contenir un texte du type: "Blah blah blah-1.12Blah blah blah 0.00". (Dans ce cas, le "-1.12" sera d'abord testé par le dernier groupe, mais l'ancre de fin de ligne fera échouer cette possibilité. Le moteur de regex ira alors directement avant le tiret pour tester (?:-[^-\n]+)).
Là encore, le but est de réduire le travail du moteur.

[Yonito]

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
public class Tester {
	public static void main(String[] args) {
		//String s = "700012838 E703       -DOMAINE PREST NON OUVERT PAR L AMC";
		String s = "000279001 E0317  0511 -INCOMPATIBILITE ASU-NAT / REGIME 0.00-1.00";
		//String s = "000001708 E0480 0051-NUAT. (DRE) 0.00-0.00";
		Pattern pattern_err = Pattern.compile("(?m)^([0-9]{9})\\s+(E[0-9]+(?: [0-9]+)?)\\s*-\\s*([^-\\n]+(?:-[^-\\n]+)*?)(?>-([0-9]+\\.[0-9]{1,2}))?$");
		Matcher match_err = pattern_err.matcher(s);
		if (match_err.matches()) {
			System.out.println(match_err.groupCount());
			for (int i = 1; i <= match_err.groupCount(); i++) {
				System.out.println("Group " + i + " : " + match_err.group(i));
			}
		}
		else System.out.println("Match not found");
	}
}

Ce code ne trouve aucune correspondance et me renvoi Match Not found.

Ce que j'ai utilisé pour l'instant est le regex suivant : ([0-9]{9})\\s+(E[0-9 ]+)-(?.*)-([0-9]+.[0-9]{1,2}))?(.*)

Ce dernier me renvoi le groupe 3 et 4 nul et le groupe 5 comporte le libelle sur un input de type : 700012838 E703 -DOMAINE PREST NON OUVERT PAR L AMC
ou me renvoi en groupe 3 le libelle et groupe 4 le dernier decimal (groupe 5 etant nul).
J'ai donc jongler entre ces deux structures la pour atteindre mon but.


tchize_ :

C'est vrai que ce n'est pas l'ideale pour de la maintenance mais j'ai l'impression que c'est le cas a chaque fois qu'on utilise les regex non ? c'est quand meme du chinois cette methode.
Quelle autre methode aurais tu ? Passer par split ?

Si oui le probleme pour split est que je pars du principe que dans un libelle il peut y avoir tous les caracteres possibles et donc cela peut rendre invalide mon split.
La deuxieme chose est que j'ai une structure suplementaire (que j'ai deja traité et donc que je n'en ai pas parlé qui est de type : 000043404 10.78-4.62 (cela correspond a une reponse qui ne comporterait aucune erreur contrairement aux autres modeles que je vous ai marqué)

Donc ce que j'ai fais pour traiter ces deux cas (avec rejet et sans rejet), je passe un premier regex pour les reponses sans erreur. S'il n'y a aucune correspondance, j'en deduis qu'il y a un rejet et donc je traite la reponse via le second regex.

Si tu as une autre solution se sera avec plaisir.

[CosmoKnacki]

OK, je vois où est le problème, il faut juste remplacer l'espace du groupe 2 par \s+.

Code :

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

(?m)^([0-9]{9})\s+(E[0-9]+(?:\s+[0-9]+)?)\s*-\s*([^-\n]+(?:-[^-\n]+)*?)(?>-([0-9]+\.[0-9]{1,2}))?$

Tu peux aussi sortir le modificateur inline (?m) de la pattern en le mettant en flag dans le code:

Code :

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

Pattern pattern_err = Pattern.compile("^([0-9]{9})\\s+(E[0-9]+(?:\\s+[0-9]+)?)\\s*-\\s*([^-\\n]+(?:-[^-\\n]+)*?)(?>-([0-9]+\\.[0-9]{1,2}))?$", Pattern.MULTILINE);

Si par contre tu traites les lignes séparément avec la méthode matches, plus besoin d'ancres ni de flag MULTILINE, ni d'exclure les nouvelles lignes dans les classes de caractères. Par contre, si tu veux gagner en lisibilité tu peux utiliser le flag COMMENTS, exemple:

Code :

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

1
2
3
4
5
6
7
8
Pattern pattern = Pattern.compile(
    "( [0-9]{9} )                       # 1er groupe: Les 9 premiers chiffres" +
    "\\s+" +
    "( E [0-9]+ (?: \\s+ [0-9]+ )? )    # 2e groupe: 'E' suivi de chiffres, espaces et autres chiffres en option" +
    "\\s* - \\s*                        # tiret avec des espaces optionnels autour" +
    "( [^-]+ (?: - [^-]+ )*? )          # 3e groupe: texte jusqu'au tiret suivi du 4e groupe ou jusqu'à la fin" +
    "(?> - ( [0-9]+ \\. [0-9]{1,2} ) )? # groupe atomique optionnel contenant un tiret suivi du 4e groupe",
    Pattern.COMMENTS);

NB: Tu peux aussi gagner en lisibilité en utilisant des captures nommées.

[tchize_]

Disons que les regexp, c'est assez imbuvable à la base. Mais quand tu commence à y ajouter des or ou des groupes non capturant ou des paramètres "non-greedy", ca deviens particulièrement imbuvable


Pardonne mois si je me trompe mais, ton format est si je comprends bien:

<code a 9 chiffres> <autre code>-[<message>][<nombre>-<nombre>]


Tirer les 9 chiffres c'est facile, repérer le premier tiret aussi. Pour le nombre-nombre à la fin, la regexp se jutifie, efficace et facile à lire.

Code :

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

1
2
3
4
5
6
7
8
code = ligne.substring(0,9);
secondePartie = ligne.substring(9);
String[] decoupe1 = secondePartie.split("-",2); // coupe en deux au premier tiret
deuxiemeCode = decoupe1[0];
troisiemePartie = decoupe1[1];
// là il faut voir si on a des nombres à la fin, on peut utiliser une regexp de type 
// "[0-9\\.]+-[0-9\\.]+$" et retirer ce que l'on trouve de troisième partie. 
// Le reste sera le message éventuel

[Yonito]

j'ai fais les deux solutions, et via regex et via des split en tout genre. Je laisse mon superieur choisir la methode qu'il preferera.

merci pour vos explications


Yoni