Tengo un pequeño progtwig que permite a los usuarios escribir algunas expresiones regulares. después me gusta comprobar si esta entrada es una expresión regular válida o no.
Me pregunto si hay un método incorporado en Java, pero no podría encontrar ese tipo de jet.
¿Me puedes dar algún consejo?
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.
Puede simplemente Pattern.compile la cadena de Pattern.compile regulares y ver si Pattern.compile la Pattern.compile 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 *** ^
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 la mirada.
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 realmente puedes tener una mirada infinita y hacer que funcione , pero no confiaría en tales comportamientos.
System.out.println( "1234".replaceAll(".(?<=(^.*))", "$1!") ); // prints "1!12!123!1234!"
Lo más obvio sería usar el método de comstackción en java.util.regex.Pattern y capturar PatternSyntaxException
String myRegEx; ... ... Pattern p = Pattern.compile(myRegEx);
Esto lanzará una PatternSyntaxException si myRegEx no es válido.
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"); } } } }
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"); } } }