web-dev-qa-db-fra.com

Comment vérifier si un Regex donné est valide?

J'ai un petit programme qui permet aux utilisateurs de saisir des expressions régulières. ensuite, j'aime vérifier si cette entrée est un valide regex ou non.

Je me demande s'il existe une méthode intégrée à Java, mais je ne pourrais pas trouver un tel jet.

Peux-tu me donner quelques conseils?

javaregex
38
Philipp Andre

Voici un exemple.

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" génère ensuite "Unclosed group", par exemple.

59
laz

Vous pouvez simplement Pattern.compile la chaîne de regex et voir si elle est 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!");
    }

Celui-ci en particulier produit la sortie suivante:

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

En ce qui concerne les regards

Voici une citation de l'ancien fidèle regular-expressions.info :

Remarques importantes sur Lookbehind

Java va encore plus loin en permettant la répétition finie. Vous ne pouvez toujours pas utiliser l'étoile ou le plus, mais vous pouvez utiliser le point d'interrogation et les accolades avec le paramètre max spécifié. Java reconnaît le fait que la répétition finie peut être réécrite sous forme d'alternance de chaînes de caractères avec {longueurs différentes mais fixes}.

Je pense que la phrase contient une faute de frappe, et devrait probablement dire "des longueurs différentes, mais finies". Dans tous les cas, Java semble permettre l’alternance de différentes longueurs dans le lookbehind.

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

Il y a aussi un bug dans lequel vous pouvez réellement avoir une longueur infinie en regardant et le faire fonctionner, mais je ne me fierais pas à de tels comportements.

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

La chose la plus évidente à faire serait d'utiliser la méthode de compilation dans Java.util.regex.Pattern et catch PatternSyntaxException

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

Cela lancera une PatternSyntaxException si myRegEx est invalide.

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

        }
    }
}
2
Kirill Sidorov
 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");
    }
 }
}
0
saigopi