Regex & Performances

Bonjour!

J'utilise l'expression régulière suivante:
[quote]
"\"(( {6})|([\\d]{6}))\",\"(( {1})|([\\d]{1}))\",\"(( {2})|([\\d]{2}))(( {8})|([\\d]{8}))\",\"[0-9][0-9AB]\",\"(( {3})|([\\d]{3}))\",\"(( {10})|([\\d]{10}))\",\"(( {2})|([\\d]{2}))\",\"(( {4})|([\\d]{4}))\",\"(( {2})|([\\d]{2}))\",\"(( {2})|([\\d]{2}))(( {2})|([\\d]{2}))\",\"(( {2})|([\\d]{2}))\",\"(( {2})|([\\d]{2}))\",\"(( {1})|([\\d]{1}))\",\"(( {2})|([\\d]{2}))\",\"(( {1})|([\\d]{1}))\",\"(( {6})|([\\d]{6}))\",\"(( {6})|([\\d]{6}))\",\"(( {6})|([\\d]{6}))\",\"(( {6})|([\\d]{6}))\",\"(( {1})|([\\d]{1}))\",\"(( {2})|([\\d]{2}))\"";
[quote]

Et mon problème actuel est que la parsing de cette expression par JDK (j'utilise le package java.util.regex) est très lent.

Alors que pour la pluspart des expressions regulières, le temps est négligeable, là il faut 3 secondes, ce qui est très bloquant quand le parsing est refat plusieurs milliers de fois (je sais c'est pas nécessaire, mais c'est comme ça...)

D'où ma question:
Est-ce que mon expression regulière est normale? Est-ce que l'usage de tant de | (or) de cette façon la ralentit? Est ce que vous voyez une alternative (en gros, ce sont des champs d'une longueur donnée qui sont soit entières vides, soit entièrement numériques)?

:merci:

Slt,
Juste un petit avis. Si ce sont des champs de textes que tu remplis et que tu veux tester, plutot que de regarder si l'expression saisie est correcte pourquoi ne pas mettre en evenement a chaque appui sur une touche du clavier pour verifier si le caractere frappe est correct et de l'afficher si c'est le cas. Ca t'evitera d'avoir une expression reguliere aussi longue.
Je ne suis pas un pro en expression reguliere mais si tu veux juste voir si le champs est numerique ou vide ton expression reguliere parait un peut longue.

Citation:

---

Envoyé par fumiste972

Juste un petit avis. Si ce sont des champs de textes que tu remplis et que tu veux tester, plutot que de regarder si l'expression saisie est correcte pourquoi ne pas mettre en evenement a chaque appui sur une touche du clavier pour verifier si le caractere frappe est correct et de l'afficher si c'est le cas. Ca t'evitera d'avoir une expression reguliere aussi longue.

---

Ce n'est pas dans cadre interactif, je dois vérifier le format d'un fichier en entrée....

Salut,


Tu peux déjà essayer de supprimer les groupes ( ) inutiles, par exemple (en rouge) : "\"(( {6})|([\\d]{6}))\"

Sinon tu peux tenter avec l'API ORO de Jakarta.

a++

PS : File nous une ligne de données qui est longue à traiter, cela pourrait nous permettre de tester ;)

Ah ok autant pour moi.

Citation:

---

Envoyé par adiGuba

PS : File nous une ligne de données qui est longue à traiter, cela pourrait nous permettre de tester ;)

---

Voila le fichier exemple et le cas de test (dépendances log4j 1.2.13 et junit 3.8.1).

:merci:

Salut,


C'est la compilation du pattern qui est très long ( 1.7 à 2 secondes chez moi). La création du matcher et l'appel à matches() est très rapide (entre 0-15ms).

Du coups lorsque tu le fait à l'intérieur de la boucle (comme dans testRegexAvanceeNoParsing()) c'est très long, mais si tu ne le compile qu'une seule fois avant (comme dans testRegexAvanceeParsing()) c'est nettement plus rapide (en fait le plus long est la compilation du pattern...

as-tu vraiment besoin de recompiler le pattern à chaque fois ???

Citation:

---

Envoyé par adiGuba

C'est la compilation du pattern qui est très long ( 1.7 à 2 secondes chez moi). La création du matcher et l'appel à matches() est très rapide (entre 0-15ms).

Du coups lorsque tu le fait à l'intérieur de la boucle (comme dans testRegexAvanceeNoParsing()) c'est très long, mais si tu ne le compile qu'une seule fois avant (comme dans testRegexAvanceeParsing()) c'est nettement plus rapide (en fait le plus long est la compilation du pattern...

as-tu vraiment besoin de recompiler le pattern à chaque fois ???

---

On est complétement d'accord sur ces points (c'est bien pour ça que j'ai fait le cas de test).

Seulement, j'utilise une application qui refait la compilation à chaque passage (l'application est nulle, mais c'est pas comme si j'avais vraiment le choix)....
Donc ma question, c'est étant donné cette application nulle, et mes contraintes de vérification, est-ce qu'il y a quelque chose d'abhérent dans mon expression regulière qui justifie ce temps, ou est-ce que c'est comme ça et on n'y peut pas grand chose? Est-ce que je peux faire quelque chose pour simplifier cette expression regulière pour soulager cette application qui refait la compilation du pattern à chaque passage?

J'ai essayé de bidouiller un peu, mais j'ai juste réussi à gagner quelques millisecondes...

• En remplacant [\\d] par \\d (ce qui est identique)
• En supprimant les parenthèses "inutiles" : ((a{5})|(b{5})) --> (a{5}|b{5})
• En supprimant les {1} qui sont implicite...

Cela donne :

Code:

---

1 2

private final String regexAvancee = "\"( {6}|\\d{6})\",\"( |\\d)\",\"( {2}|\\d{2})( {8}|\\d{8})\",\"[0-9][0-9AB]\",\"( {3}|\\d{3})\",\"( {10}|\\d{10})\",\"( {2}|\\d{2})\",\"( {4}|\\d{4})\",\"( {2}|\\d{2})\",\"( {2}|\\d{2})( {2}|\\d{2})\",\"( {2}|\\d{2})\",\"( {2}|\\d{2})\",\"( |\\d)\",\"( {2}|\\d{2})\",\"( |\\d)\",\"( {6}|\\d{6})\",\"( {6}|\\d{6})\",\"( {6}|\\d{6})\",\"( {6}|\\d{6})\",\"( |\\d)\",\"( {2}|\\d{2})\"";

---

J'obtient un temps de 1.3 secondes en moyenne... :?

Mais je ne vois pas trop quoi faire d'autre... (a part compile le pattern une seule fois :aie:)

a++

Citation:

---

Envoyé par adiGuba

J'ai essayé de bidouiller un peu, mais j'ai juste réussi à gagner quelques millisecondes...

J'obtient un temps de 1.3 secondes en moyenne... :?

Mais je ne vois pas trop quoi faire d'autre... (a part compile le pattern une seule fois :aie:)

---

Merci pour ton aide adiGuba, mais effectivement, je crois qu'il va falloir faire évoluer cette application pour qu'elle fasse un parsing et un seul.....

:merci: