java - pattern - regular expression creator online

Escapar de caracteres especiales en Java Regular Expressions

Question

¿Hay algún método en Java o alguna biblioteca de código abierto para escapar (no citar) un carácter especial (meta-carácter), para usarlo como una expresión regular?

Esto sería muy útil para construir dinámicamente una expresión regular, sin tener que escapar manualmente cada carácter individual.

Por ejemplo, considere una expresión regular simple como /d+/./d+ que coincida con números con un punto decimal como 1.2 , así como con el siguiente código:

String digit = "d";
String point = ".";
String regex1 = "//d+//.//d+";
String regex2 = Pattern.quote(digit + "+" + point + digit + "+");

Pattern numbers1 = Pattern.compile(regex1);
Pattern numbers2 = Pattern.compile(regex2);

System.out.println("Regex 1: " + regex1);

if (numbers1.matcher("1.2").matches()) {
    System.out.println("/tMatch");
} else {
    System.out.println("/tNo match");
}

System.out.println("Regex 2: " + regex2);

if (numbers2.matcher("1.2").matches()) {
    System.out.println("/tMatch");
} else {
    System.out.println("/tNo match");
}

No en vano, la salida producida por el código anterior es:

Regex 1: /d+/./d+
    Match
Regex 2: /Qd+.d+/E
    No match

Es decir, regex1 coincide con 1.2 pero regex2 (que se construye "dinámicamente") no (en cambio, coincide con la cadena literal d+.d+ ).

Entonces, ¿hay un método que escape automáticamente cada meta-carácter de expresiones regulares?

Si hubiera, digamos, un método estático de escape() en java.util.regex.Pattern , la salida de

Pattern.escape(''.'')

sería la cadena "/." , pero

Pattern.escape('','')

solo debe producir "," , ya que no es un meta-carácter. Similar,

Pattern.escape(''d'')

podría producir "/d" , ya que ''d'' se usa para denotar dígitos (aunque escapar puede no tener sentido en este caso, ya que ''d'' podría significar literal ''d'' , que el intérprete de expresiones regulares no entendería erróneamente como otra cosa, como sería el caso con ''.'' ).

Answer 1

¿Hay algún método en Java o alguna biblioteca de código abierto para escapar (no citar) un carácter especial (meta-carácter), para usarlo como una expresión regular?

No estoy 100% seguro de que esto es lo que estás preguntando aquí. Si está buscando una forma de crear constantes que pueda usar en sus patrones de expresiones regulares, entonces simplemente debe agregarlas con "//" , pero no hay una Pattern.escape(''.'') agradable de Pattern.escape(''.'') Para ayudar con esto.

Entonces, si estás tratando de hacer coincidir "//d" (la cadena /d lugar de un carácter decimal), entonces harías:

// this will match on /d as opposed to a decimal character
String matchBackslashD = "////d";
// as opposed to
String matchDecimalDigit = "//d";

Las 4 barras diagonales de la cadena Java se convierten en 2 barras diagonales en el patrón de expresiones regulares. 2 barras diagonales inversas en un patrón de expresiones regulares coinciden con la barra inversa en sí. Si se antepone cualquier carácter especial con barra diagonal inversa, se convierte en un carácter normal en lugar de uno especial.

matchPeriod = "//.";
matchPlus = "//+";
matchParens = "//(//)";
... 

En tu publicación usas el Pattern.quote(string) . Probablemente sepa que esto ajusta su patrón entre "//Q" y "//E" por lo que puede hacer coincidir una cadena incluso si tiene un carácter de expresión regular especial ( + , . , //d , etc.)

Answer 2

De acuerdo con Gray, ya que puede necesitar que su patrón tenga litrals (/ [, /]) y metacaracteres ([,]). así que con alguna utilidad, debería poder escapar de todos los caracteres primero y luego puede agregar los meta-caracteres que desea agregar en el mismo patrón.

Answer 3

Escribí este patrón:

Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()//[//].+*?^$////|]");

Y utilízalo en este método:

String escapeSpecialRegexChars(String str) {

    return SPECIAL_REGEX_CHARS.matcher(str).replaceAll("////$0");
}

Entonces puedes usarlo así, por ejemplo:

Pattern toSafePattern(String text)
{
    return Pattern.compile(".*" + escapeSpecialRegexChars(text) + ".*");
}

Necesitamos hacer eso porque, después de escapar, agregamos algunas expresiones de expresiones regulares. Si no, simplemente puede usar /Q y /E :

Pattern toSafePattern(String text)
{
    return Pattern.compile(".*//Q" + text + "//E.*")
}

Answer 4

La única forma en que el igualador de expresiones regulares sabe que está buscando un dígito y no la letra d es escapar de la letra ( /d ). Para escribir el carácter de escape de expresiones regulares en java, necesita escapar de él (por lo que / convierte en // ). Por lo tanto, no hay forma de escribir doble barras invertidas para caracteres especiales de expresiones regulares.

Answer 5

Use esta función de utilidad escapeQuotes() para escapar cadenas entre grupos y conjuntos de una RegualrExpression .

Lista de literales Regex para escapar <([{/^-=$!|]})?*+.>

public class RegexUtils {
    static String escapeChars = "//.?![]{}()<>*+-=^$|";
    public static String escapeQuotes(String str) {
        if(str != null && str.length() > 0) {
            return str.replaceAll("[//W]", "////$0"); // /W designates non-word characters
        }
        return "";
    }
}

Desde la clase Pattern , el carácter de barra diagonal inversa (''/') sirve para introducir construcciones de escape. La cadena literal "/(hello/)" es ilegal y conduce a un error en tiempo de compilación; para que coincida con la cadena (hola) se debe usar la cadena literal "//(hello//)" .

Ejemplo : cadena que debe coincidir (hello) y la expresión regular con un grupo es (/(hello/)) . Aquí, solo necesita escapar de la cadena coincidente como se muestra a continuación. ^{Test Regex online}

public static void main(String[] args) {
    String matched = "(hello)", regexExpGrup = "(" + escapeQuotes(matched) + ")";
    System.out.println("Regex : "+ regexExpGrup); // (/(hello/))
}

Answer 6

utilizar

pattern.compile("/"");
String s= p.toString()+"yourcontent"+p.toString();

dará como resultado su contenido tal como está