Expressions régulières en Java, partie 4

Nous présentons à votre attention une traduction d'un petit guide des expressions régulières en Java, rédigé par Jeff Friesen pour le site javaworld . Pour faciliter la lecture, nous avons divisé l'article en plusieurs parties. Expressions régulières en Java, partie 1 Expressions régulières en Java, partie 2 Expressions régulières en Java, partie 3

Méthodes pour travailler avec des groupes capturés

Le code source de l'application RegexDemocomprend un appel de méthode m.group(). La méthode group()est l'une des nombreuses méthodes de la classe Matchervisant à travailler avec des groupes capturés :

• La méthode int groupCount()renvoie le nombre de groupes capturés dans le modèle de résolution. Ce numéro ne prend pas en compte le numéro de groupe de capture spécial 0, qui correspond au motif dans son ensemble.

• La méthode String group()renvoie les caractères de la correspondance précédente trouvée. Pour signaler une recherche réussie d'une chaîne vide, cette méthode renvoie une chaîne vide. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode String group(int group)est similaire à la méthode précédente, sauf qu'elle renvoie les caractères de la correspondance précédente trouvée, capturés par le numéro de groupe spécifié par le paramètre group. Notez que cela group(0)équivaut à group(). Si le modèle n'a pas de groupe capturé avec le numéro donné, la méthode lève une exception IndexOutOfBoundsException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode String group(String name)renvoie les caractères de la correspondance précédente trouvée, capturés par le groupe de noms. Si le nom du groupe capturé ne figure pas dans le modèle, une exception est levée IllegalArgumentException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

L'exemple suivant montre l'utilisation des méthodes groupCount()etgroup(int group) :

Pattern p = Pattern.compile("(.(.(.)))");
Matcher m = p.matcher("abc");
m.find();
System.out.println(m.groupCount());
for (int i = 0; i <= m.groupCount(); i++)
System.out.println(i + ": " + m.group(i));

Résultats d'exécution :

3
0: abc
1: abc
2: bc
3: c

Méthodes pour déterminer les positions de match

La classe Matcherfournit plusieurs méthodes qui renvoient les positions de début et de fin d'une correspondance :

• La méthode int start()renvoie la position de départ de la correspondance précédente trouvée. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode int start(int group)est similaire à la méthode précédente, mais renvoie la position de départ de la correspondance précédente trouvée pour le groupe dont le numéro est spécifié par le paramètre group. Si le modèle n'a pas de groupe capturé avec le numéro donné, la méthode lève une exception IndexOutOfBoundsException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode int start(String name)est similaire à la méthode précédente, mais renvoie la position de départ de la correspondance précédente trouvée pour le groupe appelé name. Si le groupe capturé namene figure pas dans le modèle, une exception est levée IllegalArgumentException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode int end()renvoie la position du dernier caractère de la correspondance précédente trouvée plus 1. Si le comparateur n'a pas encore effectué de correspondance ou si l'opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode int end(int group)est similaire à la méthode précédente, mais renvoie la position finale de la correspondance précédente trouvée pour le groupe dont le numéro est spécifié par le paramètre group. Si le modèle n'a pas de groupe capturé avec le numéro donné, la méthode lève une exception IndexOutOfBoundsException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

• La méthode int end(String name)est similaire à la méthode précédente, mais renvoie la position finale de la correspondance précédente trouvée pour le groupe appelé name. Si le groupe capturé namene figure pas dans le modèle, une exception est levée IllegalArgumentException. Si le résolveur n’a pas encore effectué de recherche ou si une opération de recherche précédente a échoué, une exception est levée IllegalStateException.

L'exemple suivant illustre deux méthodes de recherche de correspondance qui génèrent les positions de début/fin de correspondance pour le groupe de capture numéro 2 :

Pattern p = Pattern.compile("(.(.(.)))");
Matcher m = p.matcher("abcabcabc");
while (m.find())
{
   System.out.println("Найдено " + m.group(2));
   System.out.println("  начинается с позиции " + m.start(2) +
                      " и заканчивается на позиции " + (m.end(2) - 1));
   System.out.println();
}

Le résultat de cet exemple est le suivant :

Найдено bc
начинается с позиции 1 и заканчивается на позиции 2
Найдено bc
начинается с позиции 4 и заканчивается на позиции 5
Найдено bc
начинается с позиции 7 и заканчивается на позиции 8

Méthodes de la classe PatternSyntaxException

Une instance de la classe PatternSyntaxExceptiondécrit une erreur de syntaxe dans l'expression régulière. Lève une telle exception à partir des méthodes compile()et matches()de la classe Patternet est formée via le constructeur suivant : PatternSyntaxException(String desc, String regex, int index) Ce constructeur stocke la description spécifiée ( desc), l'expression régulière ( regex) et la position à laquelle l'erreur de syntaxe s'est produite. Si l'emplacement de l'erreur de syntaxe est inconnu, la valeur indexest définie sur -1. Très probablement, vous n’aurez jamais besoin de créer des instances du PatternSyntaxException. Cependant, vous devrez extraire les valeurs ci-dessus lors de la création d'un message d'erreur formaté. Pour ce faire, vous pouvez utiliser les méthodes suivantes :

• La méthode String getDescription()renvoie une description de l'erreur de syntaxe.
• La méthode int getIndex()renvoie soit la position à laquelle l'erreur s'est produite, soit -1 si la position est inconnue.
• La méthode String getPattern()renvoie une expression régulière non valide.

De plus, la méthode héritée String getMessage()renvoie une chaîne multiligne avec les valeurs renvoyées par les méthodes précédentes ainsi qu'une indication visuelle de l'endroit où l'erreur de syntaxe s'est produite dans le modèle. Qu'est-ce qu'une erreur de syntaxe ? Voici un exemple : java RegexDemo (?itree Treehouse dans ce cas, nous avons oublié de spécifier le métacaractère de parenthèse fermante ( )) dans l'expression d'indicateur imbriquée. Voici le résultat de cette erreur :

regex = (?itree
input = Treehouse
Неправильное регулярное выражение: Unknown inline modifier near index 3
(?itree
   ^
Описание: Unknown inline modifier
Позиция: 3
Неправильный шаблон: (?itree

Créez des applications d'expressions régulières utiles à l'aide de l'API Regex

Les expressions régulières vous permettent de créer de puissantes applications de traitement de texte. Dans cette section, nous allons vous montrer deux applications pratiques qui, nous l'espérons, vous encourageront à explorer davantage les classes et méthodes de l'API Regex. La deuxième annexe présente Lexan : une bibliothèque de codes réutilisable pour effectuer une analyse lexicale.

Expressions régulières et documentation

La documentation est l'une des tâches obligatoires lors du développement de logiciels professionnels. Heureusement, les expressions régulières peuvent vous aider dans de nombreux aspects de la création de documentation. Le code du listing 1 extrait les lignes contenant des commentaires de style C sur une seule ligne et multilignes à partir d'un fichier source et les écrit dans un autre fichier. Pour que le code fonctionne, les commentaires doivent être sur la même ligne. Listing 1. Récupération des commentaires

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class ExtCmnt
{
   public static void main(String[] args)
   {
      if (args.length != 2)
      {
         System.err.println("Способ применения: java ExtCmnt infile outfile");
         return;
      }

      Pattern p;
      try
      {
         // Следующий шаблон определяет многострочные комментарии,
         // располагающиеся в одной строке (например, /* одна строка */)
            // и однострочные комментарии (например, // Howая-то строка).
            // Комментарий может располагаться в любом месте строки.

         p = Pattern.compile(".*/\\*.*\\*/|.*//.*$");
      }
      catch (PatternSyntaxException pse)
      {
         System.err.printf("Синтаксическая ошибка в регулярном выражении: %s%n", pse.getMessage());
         System.err.printf("Описание ошибки: %s%n", pse.getDescription());
         System.err.printf("Позиция ошибки: %s%n", pse.getIndex());
         System.err.printf("Ошибочный шаблон: %s%n", pse.getPattern());
         return;
      }

      try (FileReader fr = new FileReader(args[0]);
           BufferedReader br = new BufferedReader(fr);
           FileWriter fw = new FileWriter(args[1]);
           BufferedWriter bw = new BufferedWriter(fw))
      {
         Matcher m = p.matcher("");
         String line;
         while ((line = br.readLine()) != null)
         {
            m.reset(line);
            if (m.matches()) /* Должна соответствовать вся строка */
            {
               bw.write(line);
               bw.newLine();
            }
         }
      }
      catch (IOException ioe)
      {
         System.err.println(ioe.getMessage());
         return;
      }
   }
}

La méthode main()du listing 1 vérifie d'abord la syntaxe correcte de la ligne de commande, puis compile une expression régulière conçue pour détecter les commentaires sur une ou plusieurs lignes dans un objet de classe Pattern. Si aucune exception n'est générée PatternSyntaxException, la méthode main()ouvre le fichier source, crée le fichier cible, obtient un comparateur pour faire correspondre chaque ligne lue avec le modèle, puis lit le fichier source ligne par ligne. Pour chaque ligne, il est associé à un modèle de commentaire. En cas de succès, la méthode main()écrit la chaîne (suivie d'une nouvelle ligne) dans le fichier cible (nous aborderons la logique d'E/S du fichier dans un futur didacticiel Java 101). Compilez le listing 1 comme suit : javac ExtCmnt.java Exécutez l'application avec le fichier ExtCmnt.javaen entrée : java ExtCmnt ExtCmnt.java out Vous devriez obtenir les résultats suivants dans le fichier :

// Следующий шаблон определяет многострочные комментарии,
 // располагающиеся в одной строке (например, /* одна строка */)
    // и однострочные комментарии (например, // Howая-то строка).
    // Комментарий может располагаться в любом месте строки.
p = Pattern.compile(".*/\\*.*\\*/|.*//.*$");
    if (m.matches()) /* Должна соответствовать вся строка */

Dans la chaîne de modèle .*/\\*.*\\*/|.*//.*$, le métacaractère pipe |agit comme un opérateur logique OU, indiquant que le comparateur doit utiliser l'opérande gauche de la construction d'expression régulière donnée pour trouver une correspondance dans le texte du correspondant. S'il n'y a aucune correspondance, le comparateur utilise l'opérande de droite de la construction d'expression régulière donnée pour une autre tentative de recherche (les métacaractères parenthèses dans le groupe capturé forment également un opérateur logique). Expressions régulières en Java, partie 5