Pb de création de regex

Version imprimable

28/05/2010, 13h43
boboss123

Pb de création de regex

Bonjour,

J'ai une chaine de caractère construite comment ceci:
Une ligne contient 4 zones : chaque zone est séparée par une tabulation
- la première zone doit contenir soit "IN" soit "OUT" soit "" (vide)
- la seconde zone doit contenir soit "ERR" soit "" (vide)
- la troisième zone doit contenir un mot (ne doit pas être vide ou ne doit pas contenir plusieurs mots)
- la dernière zone doit contenir un ou plusieurs mot(ne doit pas être vide)

Je pensais faire un tru du genre :

Code:

"([IN][OUT][])\t([ERR][])\t(\\w+)\t([\\w+][\\w+ ]+)"

=> mais il ne fonctionne pas

merci d'avance,
28/05/2010, 13h56
adiGuba
Salut,

C'est normal, ceci ([IN][OUT][]) signifie :
- [IN] : une lettre parmi I ou N
- [OUT] : une lettre parmi O, U ou T
- [] : une lettre parmi aucune, soit rien
Bref cela accepte les mots IO, IU, IT, NO, NU et NT...

Ce que tu cherches à faire serait plus comme ceci : (IN|OUT|)

Sinon perso je te conseillerais de bien éclater ton pattern et de bien le document. C'est déjà galère à lire donc autant rendre cela le plus clair possible :
Code:

1 2 3 4 String pattern = "(IN|OUT|)\t" // "IN" "OUT" ou "" + "(ERR|)\t" // "ERR ou "" + "(\\w+)\t" // Un mot + "(\\w+[ \\w+]*)"; // Un mot, éventuellement suivi d'autre mots.
a++
28/05/2010, 14h02
Mobius

dans une regexp "[IN]" indique que ton expression match avec "I" ou "N"

Dans ton cas ta première zone match avec :
- IO, IU, IT, NO, NU, NT

Voici une expression (certainement pas parfaite mais) qui fonctionnerai :

Code:

(IN)?(OUT)?\t(ERR)?\t(\S+)\t(.+)

Le problème de ma regexp c'est qu'elle accepte une chaine commençant par "INOUT"

Question: Pour ta 3° zone, un mot correspond a n'importe quelle suite de caractères alphanumérique (n'importe quelle caractère n'étant pas un espace, ou juste des caractère alphabétique) ?

EDIT: Grillé (en plus avec une réponse de meilleur qualité)

merci pour vos réponse mais je voudrais vraiment que mes test soient le plus strict possible.

donc voici ma fonction de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	void funcTestRegex(String str){
 
		String pattern = "(IN|OUT|)\t"	// "IN" "OUT" ou ""
			+ "(ERR|)\t"		// "ERR ou ""
			+ "(\\w+)\t"		// Un mot
			+ "(\\w+[ \\w+]*)";	// Un mot, éventuellement suivi d'autre mots.
 
 
		Matcher matcher = Pattern.compile(pattern).matcher(str); 
 
		if (matcher.find()){
			// affichage des quatres zones
			System.out.println("match ok :" + str);
			System.out.println("\t group(1) :" + matcher.group(1).toString());
			System.out.println("\t group(2) :" + matcher.group(2).toString());
			System.out.println("\t group(3) :" + matcher.group(3).toString());
			System.out.println("\t group(4) :" + matcher.group(4).toString());
 
		} else {
			System.err.println("match error :" + str);
		}
	}

code testé :

Code:

1
2
3
		funcTestRegex("IN\tERR\tsalut\tyo");
		funcTestRegex("\tERR\tsalut\tyo");
		funcTestRegex("ININ\tERR\tsalut\tyo");

=> les trois lignes passent le test alors que la dernière ne devrait pas

28/05/2010, 14h21
adiGuba

Avec find() tu ne vérifies pas la totalité du format de la chaine, mais tu recherches une sous-chaine correspondant au pattern, et dans "ININ\tERR\tsalut\tyo" tu as la chaine ""IN\tERR\tsalut\tyo" qui correspond...

Tu dois utiliser matches() qui vérifie que la chaine corresponde bien totalement au pattern :

Code:

if (matcher.matches()) {

a++
28/05/2010, 14h23
Mobius

tu peux utiliser "^" et "$" pour indiquer le début et la fin de chaine

tu aura la regexp suivante : "^(IN|OUT|)\t(ERR|)\t(\\w+)\(\\w+[ \\w+]*)$"

EDIT: Décidément j'ai trouvé plus rapide !! Par contre cette fois ci je ne sais pas quelle solution est la meilleur. (je soupçonne quand même que la méthode d'adiGuba soit meilleur)

ok merci

"^...$" => ça marche très bien.

Il y a une différence de performance entre find et matches (sachant qu'en plus de tester le regex, il faut aussi que je récupère en même temps le contenu de mes zones)

pour la dernière zone il faudrait aussi que je puisse puisse rajouter de la ponctuation (sauf sur le premier mot => il ne faut pas que la chaine commence par de la ponctuation), je pensais donc utiliser :
Code:

1 2 3 4 5 String pattern = "^(IN|OUT|)\t" // le fichier commence par "IN" "OUT" ou "" + "(ERR|)\t" // suivit de "ERR ou "" + "(\\w+)\t" // suivit de Un mot + "(\\w+[ \\p\\w+]*)" // suivit de Un mot, éventuellement suivi d'autre mots et de ponctuation. + "$"; // fin de la ligne
=> mais j'ai une erreur
Code:

1 2 Exception in thread "main" java.util.regex.PatternSyntaxException: Unknown character property name {\} near index 32 ^(IN|OUT|) (ERR|) (\w+) (\w+[ \p\w+]*)$
ça vient de quoi ?

28/05/2010, 14h51
adiGuba

Citation:

Envoyé par Mobius

Par contre cette fois ci je ne sais pas quelle solution est la meilleur. (je soupçonne quand même que la méthode d'adiGuba soit meilleur)

D'un point de vue "technique" et "performance" je pense que c'est la même chose...

D'un point de vue "sémantique" par contre il est préférable d'utiliser matches() qui indique qu'on souhaite vérifier que le format "corresponde" au pattern, et qui correspond apparemment exactement à l'objectif de boboss123.
Alors que find() indique qu'on recherche le pattern dans une chaine.
C'est de l'ordre du détail mais c'est plus clair :l a distinction existe dans l'API donc autant la faire nous aussi...

Sinon d'après la Javadoc pour la ponctuation c'est \\p{Punct} et non pas \\p ;)

a++
28/05/2010, 15h08
Mobius

Citation:

Envoyé par adiGuba

D'un point de vue "technique" et "performance" je pense que c'est la même chose...

L'implémentation est différente. En plus avec "^" et "$" l'expression régulière est plus longue donc certainement plus longue a compiler.

Je ne vois pas pourquoi il y aurait deux implémentation autant différente s'il n'y avait pas de différence de performance.

Je dis ça mais ce ne sont que des suppositions...
28/05/2010, 15h21
boboss123

merci beaucoup mon regex à l'air de bien fonctionner ;)

Citation:

Envoyé par adiGuba

Sinon d'après la Javadoc pour la ponctuation c'est \\p{Punct} et non pas \\p ;)

oups j'ai lu un peu trop rapidement la doc (pas lu jusqu'au bout lol)

dernière petit question question, "[.^d]" ça veut dire quoi exactement ?
=> ce n'est pas la même chose que "[^d]" qui veut dire n'importe quel caractère sauf 'd'
28/05/2010, 15h21
adiGuba

Je ne pense pas que ce soit si différent que cela. Le traitement doit être sensiblement le même si ce n'est que find() doit gérer un index de départ...

Pour moi c'est la même chose qu'entre contains() ou indexOf() sur une chaine. Les deux permettent de savoir si une chaine contient une sous-chaine, mais la première est plus approprié pour cela ;)

a++
28/05/2010, 15h24
adiGuba

Citation:

Envoyé par boboss123

dernière petit question question, "[.^d]" ça veut dire quoi exactement ?
=> ce n'est pas la même chose que "[^d]" qui veut dire n'importe quel caractère sauf 'd'

Cela veut dire : un caractère parmis ".", "^" ou "d".

Le ^ n'a une signification particulière que lorsqu'il est en première position dans le [ ].
Quand au point, il est n'a aucun sens spécial dans un bloc [ ]

a++
28/05/2010, 15h34
boboss123

oki, merci pour cet éclaircissement