Espressioni regolari in Java, parte 4

Presentiamo alla vostra attenzione la traduzione di una breve guida alle espressioni regolari in Java, scritta da Jeff Friesen per il sito javaworld . Per facilitare la lettura abbiamo diviso l’articolo in più parti. Espressioni regolari in Java, Parte 1 Espressioni regolari in Java, Parte 2 Espressioni regolari in Java, Parte 3

Metodi per lavorare con i gruppi catturati

Il codice sorgente dell'applicazione RegexDemoinclude una chiamata al metodo m.group(). Il metodo group()è uno dei numerosi metodi della classe Matchervolti a lavorare con i gruppi catturati:

• Il metodo int groupCount()restituisce il numero di gruppi acquisiti nel modello del risolutore. Questo numero non tiene conto dello speciale gruppo di cattura numero 0, che corrisponde al modello nel suo insieme.

• Il metodo String group()restituisce i caratteri della corrispondenza precedente trovata. Per segnalare una ricerca riuscita di una stringa vuota, questo metodo restituisce una stringa vuota. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo String group(int group)è simile al metodo precedente, tranne per il fatto che restituisce i caratteri della corrispondenza precedente trovata, catturati dal numero di gruppo specificato dal parametro group. Tieni presente che questo group(0)equivale a group(). Se il modello non dispone di un gruppo acquisito con il numero specificato, il metodo genera un'eccezione IndexOutOfBoundsException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo String group(String name)restituisce i caratteri della corrispondenza precedente trovata, catturati dal gruppo di nomi. Se il nome del gruppo acquisito non è presente nel modello, viene generata un'eccezione IllegalArgumentException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

L'esempio seguente dimostra l'uso dei metodi groupCount()e group(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));

Risultati dell'esecuzione:

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

Metodi per determinare le posizioni delle partite

La classe Matcherfornisce diversi metodi che restituiscono le posizioni iniziale e finale di una corrispondenza:

• Il metodo int start()restituisce la posizione iniziale della corrispondenza precedente trovata. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo int start(int group)è simile al metodo precedente, ma restituisce la posizione iniziale della corrispondenza precedente trovata per il gruppo il cui numero è specificato dal parametro group. Se il modello non dispone di un gruppo acquisito con il numero specificato, il metodo genera un'eccezione IndexOutOfBoundsException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo int start(String name)è simile al metodo precedente, ma restituisce la posizione iniziale della corrispondenza precedente trovata per il gruppo denominato name. Se il gruppo acquisito namenon è presente nel modello, viene generata un'eccezione IllegalArgumentException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo int end()restituisce la posizione dell'ultimo carattere della corrispondenza precedente trovata più 1. Se il matcher non ha ancora eseguito una corrispondenza o l'operazione di ricerca precedente non è riuscita, viene lanciata un'eccezione IllegalStateException.

• Il metodo int end(int group)è simile al metodo precedente, ma restituisce la posizione finale della corrispondenza precedente trovata per il gruppo il cui numero è specificato dal parametro group. Se il modello non dispone di un gruppo acquisito con il numero specificato, il metodo genera un'eccezione IndexOutOfBoundsException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

• Il metodo int end(String name)è simile al metodo precedente, ma restituisce la posizione finale della corrispondenza precedente trovata per il gruppo chiamato name. Se il gruppo acquisito namenon è presente nel modello, viene generata un'eccezione IllegalArgumentException. Se il risolutore non ha ancora eseguito una ricerca o un'operazione di ricerca precedente non è riuscita, viene generata un'eccezione IllegalStateException.

L'esempio seguente dimostra due metodi di individuazione della corrispondenza che restituiscono le posizioni di inizio/fine corrispondenza per il gruppo di acquisizione numero 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();
}

L'output di questo esempio è il seguente:

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

Metodi della classe PatternSyntaxException

Un'istanza della classe PatternSyntaxExceptiondescrive un errore di sintassi nell'espressione regolare. Genera tale eccezione dai metodi compile()e matches()dalla classe Patterne viene formata tramite il seguente costruttore: PatternSyntaxException(String desc, String regex, int index) Questo costruttore memorizza la descrizione specificata ( desc), l'espressione regolare ( regex) e la posizione in cui si è verificato l'errore di sintassi. Se la posizione dell'errore di sintassi è sconosciuta, il valore indexè impostato su -1. Molto probabilmente, non avrai mai bisogno di creare istanze di PatternSyntaxException. Tuttavia, dovrai estrarre i valori sopra indicati durante la creazione di un messaggio di errore formattato. Per fare ciò, è possibile utilizzare i seguenti metodi:

• Il metodo String getDescription()restituisce una descrizione dell'errore di sintassi.
• Il metodo int getIndex()restituisce la posizione in cui si è verificato l'errore oppure -1 se la posizione è sconosciuta.
• Il metodo String getPattern()restituisce un'espressione regolare non valida.

Inoltre, il metodo ereditato String getMessage()restituisce una stringa su più righe con i valori restituiti dai metodi precedenti insieme a un'indicazione visiva di dove si è verificato l'errore di sintassi nel modello. Cos'è un errore di sintassi? Ecco un esempio: java RegexDemo (?itree Treehouse in questo caso, ci siamo dimenticati di specificare il metacarattere della parentesi di chiusura ( )) nell'espressione flag nidificata. Questo è ciò che viene prodotto da questo errore:

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

Crea utili applicazioni di espressioni regolari utilizzando l'API Regex

Le espressioni regolari consentono di creare potenti applicazioni di elaborazione del testo. In questa sezione ti mostreremo due pratiche applicazioni che, si spera, ti incoraggeranno a esplorare ulteriormente le classi e i metodi dell'API Regex. La seconda appendice introduce Lexan: una libreria di codici riutilizzabile per eseguire analisi lessicali.

Espressioni regolari e documentazione

La documentazione è uno dei compiti obbligatori quando si sviluppa software professionale. Fortunatamente, le espressioni regolari possono aiutarti in molti aspetti della creazione della documentazione. Il codice nel Listato 1 estrae le righe contenenti commenti in stile C a riga singola e multilinea da un file sorgente e le scrive in un altro file. Perché il codice funzioni, i commenti devono essere sulla stessa riga. Listato 1. Recupero dei commenti

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;
      }
   }
}

Il metodo main()nel Listato 1 controlla innanzitutto la corretta sintassi della riga di comando e quindi compila un'espressione regolare progettata per rilevare commenti su riga singola e multilinea in un oggetto di classe Pattern. Se non viene sollevata alcuna eccezione PatternSyntaxException, il metodo main()apre il file di origine, crea il file di destinazione, ottiene un matcher per abbinare ogni riga letta rispetto al modello e quindi legge il file di origine riga per riga. Ad ogni riga viene abbinato uno schema di commento. In caso di successo, il metodo main()scrive la stringa (seguita da una nuova riga) nel file di destinazione (illustreremo la logica I/O del file in un futuro tutorial su Java 101). Compila il Listato 1 come segue: javac ExtCmnt.java Esegui l'applicazione con file ExtCmnt.javacome input: java ExtCmnt ExtCmnt.java out Dovresti ottenere i seguenti risultati in file out:

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

Nella stringa del modello .*/\\*.*\\*/|.*//.*$, il metacarattere pipe |agisce come un operatore logico OR, indicando che il matcher deve utilizzare l'operando sinistro del costrutto dell'espressione regolare specificato per trovare una corrispondenza nel testo del matcher. Se non ci sono corrispondenze, il matcher utilizza l'operando destro del costrutto dell'espressione regolare specificato per un altro tentativo di ricerca (anche i metacaratteri tra parentesi nel gruppo catturato formano un operatore logico). Espressioni regolari in Java, parte 5