précédent | suivant | table des matières

expressions régulières

Des application de test, RegexSR, et JRegexpTester, et un tutoriel, et le tutoriel de SUN. (expressions régulières et automates)

Les expressions régulières ou rationnelles sont des expressions construites à partir de constantes  et d'opérateurs.

Les constantes sont :

• ensemble vide (noté Ø ) : désigne l'ensemble vide (aucune chaîne de caractère n'est dans Ø) ;
• mot vide ou chaîne vide (noté ε ) : désigne la chaîne de caractères qui ne contient aucune lettre ;
• caractère littéral (noté a) :  a est un élément de Σ (le vocabulaire de l'expression régulière).

Les opérateurs de base sont :

• concaténation (notée par un point ou par rien) : si E₁ et E₂ sont deux expressions rationnelles, alors E₁E₂ (ou E₁.E₂) est une expression rationnelle.
• ou (notée | ) : si E₁ et E₂ sont deux expressions rationnelles, alors E₁ | E₂ est une expression rationnelle.
• fermeture de Kleene (notée *) : si E est une expression rationnelle, alors E* est une expression rationnelle.

Les priorités habituellement utilisées sont (dans l'ordre décroissant) *, concaténation, et ou. On peut utiliser des parenthèses dans les expressions rationnelles. L'opérateur + est défini de la façon suivante : E+ ≡ E | E*.

On note Rat(A) l'ensemble des expressions rationnelles sur le vocabulaire A. A toute expression rationnelle E appartenant à Rat(A) correspond un langage L(E) défini de la façon suivante :

L(∅) = ∅ L(ε) = {ε} L(A) = {a, a∈A} L(E*) = (L(E))* avec {a}* = {ε, a, aa, aaa, ...} L(E1 | E2) = L(E1) ∪ L(E2) L(E1E2) = L(E1)L(E2) avec {a, b}{c, d} = {ac, ad, bc, bd}

Eléments de théorie des automates, Jacques Sakarovitch (vuibert informatique)

L'appariement (concordance) d'une expression rationnelle avec une chaîne de caractères consiste à trouver dans la chaîne de caractères les occurrences d'éléments de L(E).

Trois classes interviennent dans les utilisations d'expressions régulières en Java :

• Pattern : permet d'obtenir une version compilée d'une expression régulière.
• Matcher : permet d'analyser une chaîne en entrée à partir d'un Pattern.
• PatternSyntaxException : exception levée lorsque la syntaxe d'une expression régulière n'est pas correcte.

try{
   Pattern p = Pattern .compile("a*b|c");
   String entree = "aabbbcab";
   Matcher m = p.matcher(entree);
   while (m.find())
      System.out.println(entree.substring(m.start(), m.end()));
}catch(PatternSyntaxException pse){
}

La classe Matcher accomplit les opérations de reconnaissance d'un motif sur une chaîne.

Il y a 3 sortes d'opérations de reconnaissance :

1. la méthode boolean matches() qui essaie de reconnaître le motif sur la séquence en entier.
2. la méthode boolean lookingAt() qui essaie de reconnaître le motif sur  la séquence à partir du début, et pas forcément jusqu'à la fin. Les méthodes start(), end() et group() permettent d'obtenir plus d'informations.
3. les méthodes boolean find() et boolean find(int d) qui essaient de reconnaître le motif une partie de la séquence en entrée.Les méthodes start(), end() et group() permettent d'obtenir plus d'informations.

Cette classe permet aussi de remplacer les sous séquences reconnues par le Matcher, éventuellement en fonction de la chaîne reconnue.

Les méthodes de Matcher :

Dans les chaînes de remplacement des méthodes suivantes $i désigne le i^ème groupe reconnu par le Matcher avant remplacement.

Matcher appendReplacement(
          StringBuffer sb,
          String remplace)

Pattern p = Pattern.compile("....");
Matcher m = p.matcher("....");
StringBuffer sb = new StringBuffer();
while(m.find())
   m.appendReplacement(sb, "...");
m.appendTail(sb);

StringBuffer appendTail(StringBuffer sb)

String replaceAll(String remplace)

String replaceFirst(String remplace)

Une expression régulière est construite à partir de caractères et d'opérateurs. L'utilisation des différents caractères et opérateurs est expliquée dans les paragraphes qui suivent.

Les caractères utilisés dans une expression rationnelles sont les caractères unicode java, plus les caractères spéciaux suivants :

Ce sont des caractères qui sont interprétés par l'analyseur. Pour qu'un méta-caractère ne soit par interprété par l'analyseur, il faut le faire précéder du caractère '\'. Les caractères '-' et ']' ont un statut spécial : dans un intervalle ce sont des méta-caractères, et en dehors d'un intervalle ils se comportent comme des caractères normaux.

• [a\]b]*c est équivalent à (a|]|b)*c
• [a\-b]*c est équivalent à (a|-|b)*c

Une classe de caractères peut être définie par le programmeur  en écrivant entre [ ] la liste des caracères de la classe, et en utilisant les opérateurs d'union (non marqué), d'intersection (&&) et de négation (^) :

Les classes de caractères POSIX sont :

Les classes de caractères Java sont :

Les classes de caractères Unicode sont :

Les quantificateurs sont

• + : une ou plusieurs occurrences.
• * : zéro, une ou plusieurs occurrences.
• ? : zéro ou une occurrence.
• {n} : exactement n occurrences.
• {n,} : au moins n occurrences.
• {n,m} : de n à m (inclus) occurrences.

Les quantificateurs précédents sont qualifiés de 3 façons différentes :

• avides : le matcheur lit toute la chaîne avant d'essayer la première concordance. Si l'appariement échoue, le matcheur recule d'un caractère, puis recommence ... et ainsi de suite.  La recherche du motif .*abc dans la chaîne abcxxxxxxabcxxxxabc trouve une occurrence de 0 à 19.
• réticent noté par ? : la premère réussite est la bonne ! La recherche du motif .*?abc dans la chaîne abcxxxxxxabcxxxxabc trouve trois occurrences, une de 0 à 3, une de 3 à 12 et une 12 de à 19.
• possessif noté par + : pareil que avide, mais si ça échoue, on ne recommence pas ! La recherche du motif .*+abc dans la chaîne abcxxxxxxabcxxxxabc ne trouve pas de concordance : en effet, .*+ mange tout jusqu'à la fin de la chaîne, et donc ce n'est pas suivi de abc

Exemple :

Pattern p = Pattern.compile("(a((b)(c)))");
Matcher m = p.matcher("abc");
if( m.matches())
   for(int i= 0; i<= m.groupCount(); ++i)
      System.out.println("\n"+"groupe "+i+" :"+m.group(i));

A l'intérieur d'un motif, on peut faire référence à un groupe du même motif en écrivant \i : i étant le numéro du groupe.

L'expression (\w\w)\1 permet de reconnaître des mots tels que titi, toto, tutu, zozo ...

Un groupe peut ne pas être capturé : il suffit de le faire commencer par (?: . On dit qu'on a un groupe pur.

Un groupe peut être utilisé avant son occurrence dans l'expression régulière :  (\2deux|(un))+ permet de reconnaître des chaînes reconnues par l'expression un(((un)+(deux){0,1})*).
Lors de l'analyse, au premier passage \2 n'a pas de valeur, il y a donc echec, mais au deuxième passage, il peut avoir été affecté de "un", et l'analyse continue.

Les spécificateurs de frontière sont des indicateurs permettant de dire où commence ou où finit le motif.

Exemple :

On peut conditionner l'analyse d'une expression régulière à la réussite de l'analyse d'une autre expression (Look-ahead positif: (?=, ou Look-behind positif(?<=), ou à l'échec de l'analyse d'une autre expression (Look-ahead négatif(?!) ou Look-behind négatif (?<! ).

exemples :

• (?=255)(\d{1,3}\.){3}\d{1,3} permet de reconnaître des N° IP qui commencent par 255.
• (?!255)(\d{1,3}\.){3}\d{1,3} permet de reconnaître des N° IP qui ne commencent pas par 255.
• (?<=http://((\S){1,20}:(\S){1,20}@)?)[\S&&[^:/]]+ permet de reconnaître le nom d'une machine dans une URL de protocole http. (Une URL peut avoir une chaîne nomUtilisateur: motDePasse@ avant le nom de la machine. Le Look-behind doit être borné en longueur.
• • \d+(?!\.) permet de reconnaître un entier qui n'est pas suivi par un point.
  • \d+(?=[^.]) permet de reconnaître un entier qui est suivi de n'importe quoi sauf un point. Cette expression ne reconnaît pas les entiers en fin de chaîne, alors que la précédente les reconnaît.

Les options (sauf CANON_EQ et LITERAL) peuvent être activées localement à l'intérieur d'une expression régulière. Quand les options sont embarquées, elles sont valable pour le groupe dans lequel elles sont embarquées, ou pour toute l'expression si elles sont en début d'expression.
Exemple :

• (a)*b     apparié avec xxxaaAabxxxaaAaBxxx ne trouve que ab
• ((?i)a)*b apparié avec xxxaaAabxxxaaAaBxxx ne trouve que aaAab
• (?i)(a)*b apparié avec xxxaaAabxxxaaAaBxxx trouve aaAab et aaAaB

Pattern.compile("a*b", Pattern.COMMENTS | Pattern.CASE_INSENSITIVE)