java - sheet - ¿Cómo verificar si un Regex dado es válido?

java util regex

Question

Tengo un pequeño programa que permite a los usuarios escribir algunas expresiones regulares. luego me gustaría comprobar si esta entrada es una expresión regular válida o no.

Me pregunto si hay un método de compilación en Java, pero no pude encontrar dicho jet.

¿Me puedes dar algún consejo?

Answer 1

Aquí hay un ejemplo.

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

public class RegexTester {
    public static void main(String[] arguments) {
        String userInputPattern = arguments[0];
        try {
            Pattern.compile(userInputPattern);
        } catch (PatternSyntaxException exception) {
            System.err.println(exception.getDescription());
            System.exit(1);
        }
        System.out.println("Syntax is ok.");
    }
}

java RegexTester "(capture" luego emite "Unclosed group" , por ejemplo.

Answer 2

La cosa más obvia sería utilizar el método de compilación en java.util.regex.Pattern y capturar PatternSyntaxException

String myRegEx;
...
...
Pattern p = Pattern.compile(myRegEx);

Esto lanzará una excepción PatternSyntaxException si myRegEx no es válido.

Answer 3

Puede simplemente Pattern.compile la cadena de Pattern.compile regulares y ver si throws PatternSyntaxException .

    String regex = "***";
    PatternSyntaxException exc = null;
    try {
        Pattern.compile(regex);
    } catch (PatternSyntaxException e) {
        exc = e;
    }
    if (exc != null) {
        exc.printStackTrace();
    } else {
        System.out.println("Regex ok!");
    }

Este en particular produce el siguiente resultado:

java.util.regex.PatternSyntaxException: Dangling meta character ''*'' near index 0
***
^

Respecto a las miradas

Aquí hay una cita de la antigua trusty regular-expressions.info :

Notas importantes sobre Lookbehind

Java lleva las cosas un paso más allá al permitir la repetición finita. Aún no puede usar la estrella o más, pero puede usar el signo de interrogación y las llaves con el parámetro máximo especificado. Java reconoce el hecho de que la repetición finita se puede reescribir como una alternancia de cadenas con longitudes diferentes pero fijas .

Creo que la frase contiene un error tipográfico, y probablemente debería decir "longitudes diferentes, pero finitas". En cualquier caso, Java parece permitir la alternancia de diferentes longitudes en lookbehind.

    System.out.println(
        java.util.Arrays.toString(
            "abracadabra".split("(?<=a|ab)")
        )
    ); // prints "[a, b, ra, ca, da, b, ra]"

También hay un error en el que puedes tener un aspecto de longitud infinita y hacer que funcione , pero no confiaría en esos comportamientos.

    System.out.println(
        "1234".replaceAll(".(?<=(^.*))", "$1!")
    ); // prints "1!12!123!1234!"

Answer 4

 public class Solution
 {
 public static void main(String[] args){
  Scanner in = new Scanner(System.in);
  int testCases = Integer.parseInt(in.nextLine());
  while(testCases>0){
     String pattern = in.nextLine();
      try
      {
          Pattern.compile(pattern);
      }
      catch(Exception e)
      {
         // System.out.println(e.toString());
          System.out.println("Invalid");
      }
      System.out.println("Valid");
    }
 }
}

Answer 5

public class Solution {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int testCases = Integer.parseInt(in.nextLine());
        while(testCases>0){
            String pattern = in.nextLine();
            try{
                Pattern.compile(pattern);
                System.out.println("Valid");
            }catch(PatternSyntaxException exception){
                System.out.println("Invalid");
            }

        }
    }
}