Lista de todos los caracteres especiales que deben escaparse en una expresión regular

Estoy intentando crear una aplicación que coincida con una plantilla de mensaje con un mensaje que un usuario está intentando enviar. Estoy usando Java regex para hacer coincidir el mensaje. La plantilla / mensaje puede contener caracteres especiales.

¿Cómo obtendría la lista completa de caracteres especiales que deben escaparse para que mi expresión regular funcione y coincida en el máximo de casos posibles?

¿Existe una solución universal para escapar de todos los caracteres especiales en Java regex?

Puede ver el javadoc de la clase Pattern: http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html

Debe escapar de cualquier carácter enumerado allí si desea el carácter regular y no el significado especial.

Como una solución tal vez más simple, puede colocar la plantilla entre \ Q y \ E; todo lo que hay entre ellos se considera escapado.

• Los caracteres de Java que deben escaparse en expresiones regulares son:
  \.[]{}()<>*+-=!?^$|
• Solo es necesario escapar dos de los soportes de cierre ( ]y }) después de abrir el mismo tipo de soporte.
• Entre []paréntesis, algunos caracteres (como +y -) a veces funcionan sin escape.

Para escapar, puede usar esto de Java 1.5 :

Pattern.quote("$test");

Coincidirás exactamente con la palabra $test

De acuerdo con la página de documentación de String Literals / Metacharacters , son:

<([{\^-=$!|]})?*+.>

También sería genial tener esa lista referenciada en algún lugar del código, pero no sé dónde podría estar ...

Combinando lo que todos dijeron, propongo lo siguiente, para mantener la lista de caracteres especiales para RegExp claramente enumerados en su propia Cadena, y para evitar tener que intentar analizar visualmente miles de "\\". Esto parece funcionar bastante bien para mí:

final String regExSpecialChars = "<([{\\^-=$!|]})?*+.>";
final String regExSpecialCharsRE = regExSpecialChars.replaceAll( ".", "\\\\$0");
final Pattern reCharsREP = Pattern.compile( "[" + regExSpecialCharsRE + "]");

String quoteRegExSpecialChars( String s)
{
    Matcher m = reCharsREP.matcher( s);
    return m.replaceAll( "\\\\$0");
}

En la sugerencia de @ Sorin de los documentos de Java Pattern, parece que los caracteres para escapar son al menos:

\.[{(*+?^$|

El Pattern.quote(String s)tipo de hace lo que quieres. Sin embargo, deja un poco que desear; en realidad no se escapa de los caracteres individuales, solo envuelve la cadena con \Q...\E.

No existe un método que haga exactamente lo que está buscando, pero la buena noticia es que en realidad es bastante simple escapar de todos los caracteres especiales en una expresión regular de Java:

regex.replaceAll("[\\W]", "\\\\$0")

¿Por qué funciona esto? Bueno, la documentación para Patternespecíficamente dice que está permitido escapar de los caracteres no alfabéticos que no necesariamente tienen que escaparse:

Es un error usar una barra invertida antes de cualquier carácter alfabético que no denote una construcción de escape; estos están reservados para futuras extensiones del lenguaje de expresiones regulares. Se puede usar una barra invertida antes de un carácter no alfabético independientemente de si ese carácter es parte de una construcción sin escape.

Por ejemplo, ;no es un carácter especial en una expresión regular. Sin embargo, si lo escapas, Patternaún se interpretará \;como ;. Aqui hay algunos ejemplos mas:

• >se convierte en lo \>que es equivalente a>
• [se convierte en \[cuál es la forma escapada de[
• 8está quieto 8.
• \)se convierte en lo \\\)que son las formas escapadas \y (concatenadas.

Nota: La clave es la definición de "no alfabético", que en la documentación realmente significa caracteres "que no son palabras " o caracteres fuera del conjunto de caracteres [a-zA-Z_0-9].

En el otro lado de la moneda, debe usar expresiones regulares "sin caracteres" que se vean así si los caracteres especiales = allChars - número - ABC - espacio en el contexto de su aplicación.

String regepx = "[^\\s\\w]*";

aunque la respuesta es para Java, pero el código se puede adaptar fácilmente de esta extensión de Kotlin String que se me ocurrió (adaptado de la que @brcolow proporcionó):

private val escapeChars = charArrayOf(
    '<',
    '(',
    '[',
    '{',
    '\\',
    '^',
    '-',
    '=',
    '$',
    '!',
    '|',
    ']',
    '}',
    ')',
    '?',
    '*',
    '+',
    '.',
    '>'
)

fun String.escapePattern(): String {
    return this.fold("") {
      acc, chr ->
        acc + if (escapeChars.contains(chr)) "\\$chr" else "$chr"
    }
}

fun main() {
    println("(.*)".escapePattern())
}

huellas dactilares \(\.\*\)

compruébalo en acción aquí https://pl.kotl.in/h-3mXZkNE

Suponiendo que tiene y confía (para ser autorizado) la lista de caracteres de escape que usa Java regex (sería bueno si estos caracteres estuvieran expuestos en algún miembro de la clase Pattern), puede usar el siguiente método para escapar del carácter si es realmente necesario:

private static final char[] escapeChars = { '<', '(', '[', '{', '\\', '^', '-', '=', '$', '!', '|', ']', '}', ')', '?', '*', '+', '.', '>' };

private static String regexEscape(char character) {
    for (char escapeChar : escapeChars) {
        if (character == escapeChar) {
            return "\\" + character;
        }
    }
    return String.valueOf(character);
}