Expresiones regulares en Java, Parte 4

Presentamos a su atención una traducción de una breve guía sobre expresiones regulares en Java, escrita por Jeff Friesen para el sitio web javaworld . Para facilitar la lectura, hemos dividido el artículo en varias partes. Expresiones regulares en Java, Parte 1 Expresiones regulares en Java, Parte 2 Expresiones regulares en Java, Parte 3

Métodos para trabajar con grupos capturados.

El código fuente de la aplicación RegexDemoincluye una llamada a un método m.group(). El método group()es uno de varios métodos de la clase Matcherdestinados a trabajar con grupos capturados:

• El método int groupCount()devuelve el número de grupos capturados en el patrón de resolución. Este número no tiene en cuenta el grupo de captura especial número 0, que corresponde al patrón en su conjunto.

• El método String group()devuelve los caracteres de la coincidencia anterior encontrada. Para informar de una búsqueda exitosa de una cadena vacía, este método devuelve una cadena vacía. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método String group(int group)es similar al método anterior, excepto que devuelve los caracteres de la coincidencia anterior encontrada, capturados por el número de grupo especificado por el parámetro group. Tenga en cuenta que esto group(0)equivale a group(). Si la plantilla no tiene un grupo capturado con el número dado, el método genera una excepción IndexOutOfBoundsException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método String group(String name)devuelve los caracteres de la coincidencia anterior encontrada, capturados por el grupo de nombres. Si el nombre del grupo capturado no está en la plantilla, se genera una excepción IllegalArgumentException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

El siguiente ejemplo demuestra el uso de los métodos groupCount()y 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));

Resultados de la ejecución:

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

Métodos para determinar las posiciones de los partidos.

La clase Matcherproporciona varios métodos que devuelven las posiciones inicial y final de una partida:

• El método int start()devuelve la posición inicial de la coincidencia anterior encontrada. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método int start(int group)es similar al método anterior, pero devuelve la posición inicial de la coincidencia anterior encontrada para el grupo cuyo número está especificado por el parámetro group. Si la plantilla no tiene un grupo capturado con el número dado, el método genera una excepción IndexOutOfBoundsException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método int start(String name)es similar al método anterior, pero devuelve la posición inicial de la coincidencia anterior encontrada para el grupo llamado name. Si el grupo capturado nameno está en la plantilla, se genera una excepción IllegalArgumentException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método int end()devuelve la posición del último carácter de la coincidencia anterior encontrada más 1. Si el comparador aún no ha realizado una coincidencia o la operación de búsqueda anterior falló, se lanza una excepción IllegalStateException.

• El método int end(int group)es similar al método anterior, pero devuelve la posición final de la coincidencia anterior encontrada para el grupo cuyo número se especifica mediante el parámetro group. Si la plantilla no tiene un grupo capturado con el número dado, el método genera una excepción IndexOutOfBoundsException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

• El método int end(String name)es similar al método anterior, pero devuelve la posición final de la coincidencia anterior encontrada para el grupo llamado name. Si el grupo capturado nameno está en la plantilla, se genera una excepción IllegalArgumentException. Si el solucionador aún no ha realizado una búsqueda o si una operación de búsqueda anterior falló, se genera una excepción IllegalStateException.

El siguiente ejemplo demuestra dos métodos de ubicación de coincidencia que generan las posiciones de inicio/fin de coincidencia para el grupo de captura número 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();
}

El resultado de este ejemplo es el siguiente:

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

Métodos de la clase PatternSyntaxException

Una instancia de la clase PatternSyntaxExceptiondescribe un error de sintaxis en la expresión regular. Lanza una excepción de este tipo desde los métodos compile()y matches()la clase Pattern, y se forma mediante el siguiente constructor: PatternSyntaxException(String desc, String regex, int index) Este constructor almacena la descripción especificada ( desc), la expresión regular ( regex) y la posición en la que ocurrió el error de sintaxis. Si se desconoce la ubicación del error de sintaxis, el valor indexse establece en -1. Lo más probable es que nunca necesites crear instancias de PatternSyntaxException. Sin embargo, deberá extraer los valores anteriores al crear un mensaje de error formateado. Para hacer esto, puede utilizar los siguientes métodos:

• El método String getDescription()devuelve una descripción del error de sintaxis.
• El método int getIndex()devuelve la posición en la que ocurrió el error o -1 si la posición es desconocida.
• El método String getPattern()devuelve una expresión regular no válida.

Además, el método heredado String getMessage()devuelve una cadena de varias líneas con los valores devueltos por métodos anteriores junto con una indicación visual de dónde ocurrió el error de sintaxis en la plantilla. ¿Qué es un error de sintaxis? A continuación se muestra un ejemplo: java RegexDemo (?itree Treehouse en este caso, olvidamos especificar el metacarácter del paréntesis de cierre ( )) en la expresión del indicador anidado. Esto es lo que se genera con este error:

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

Cree aplicaciones útiles de expresiones regulares utilizando la API Regex

Las expresiones regulares le permiten crear potentes aplicaciones de procesamiento de texto. En esta sección, le mostraremos dos aplicaciones útiles que, con suerte, lo alentarán a explorar más a fondo las clases y métodos de la API Regex. El segundo apéndice presenta Lexan: una biblioteca de código reutilizable para realizar análisis léxicos.

Expresiones regulares y documentación.

La documentación es una de las tareas obligatorias a la hora de desarrollar software profesional. Afortunadamente, las expresiones regulares pueden ayudarte con muchos aspectos de la creación de documentación. El código del Listado 1 extrae líneas que contienen comentarios estilo C de una o varias líneas de un archivo fuente y las escribe en otro archivo. Para que el código funcione, los comentarios deben estar en la misma línea. Listado 1. Recuperar comentarios

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
      {
         // Следующий шаблон определяет многострочные комментарии,
         // располагающиеся в одной строке (например, /* одна строка */)
            // и однострочные комментарии (например, // Cómoая-то строка).
            // Комментарий может располагаться в любом месте строки.

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

El método main()del Listado 1 primero verifica la sintaxis correcta de la línea de comandos y luego compila una expresión regular diseñada para detectar comentarios de una o varias líneas en un objeto de clase Pattern. Si no se genera ninguna excepción PatternSyntaxException, el método main()abre el archivo fuente, crea el archivo de destino, obtiene un comparador para hacer coincidir cada línea leída con el patrón y luego lee el archivo fuente línea por línea. Para cada línea, se combina con un patrón de comentario. Si tiene éxito, el método main()escribe la cadena (seguida de una nueva línea) en el archivo de destino (cubriremos la lógica de E/S del archivo en un futuro tutorial de Java 101). Compile el Listado 1 de la siguiente manera: javac ExtCmnt.java Ejecute la aplicación con el archivo ExtCmnt.javacomo entrada: java ExtCmnt ExtCmnt.java out Debería obtener los siguientes resultados en el archivo:

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

En la cadena de patrón .*/\\*.*\\*/|.*//.*$, el metacarácter de tubería |actúa como un operador lógico OR, lo que indica que el comparador debe usar el operando izquierdo de la construcción de expresión regular dada para encontrar una coincidencia en el texto del comparador. Si no hay coincidencias, el comparador utiliza el operando correcto de la expresión regular dada para otro intento de búsqueda (los metacaracteres entre paréntesis en el grupo capturado también forman un operador lógico). Expresiones regulares en Java, Parte 5