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