Lista de todos os caracteres especiais que precisam ser escapados em uma regex

Estou tentando criar um aplicativo que corresponda a um modelo de mensagem com uma mensagem que um usuário está tentando enviar. Estou usando Java regex para corresponder à mensagem. O modelo / mensagem pode conter caracteres especiais.

Como obteria a lista completa de caracteres especiais que precisam ser escapados para que minha regex funcione e corresponda no máximo de casos possíveis?

Existe uma solução universal para escapar de todos os caracteres especiais no Java regex?

Você pode olhar o javadoc da classe Pattern: http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html

Você precisa escapar de qualquer caractere listado lá se quiser o caractere regular e não o significado especial.

Como uma solução talvez mais simples, você pode colocar o modelo entre \ Q e \ E - tudo entre eles é considerado como escape.

• Os caracteres Java que devem ser escapados em expressões regulares são:
  \.[]{}()<>*+-=!?^$|
• Dois dos colchetes de fechamento ( ]e }) só precisam ser escapados após a abertura do mesmo tipo de colchete.
• Entre []colchetes, alguns caracteres (como +e -) às vezes funcionam sem escape.

Para escapar, você pode apenas usar isso do Java 1.5 :

Pattern.quote("$test");

Você vai corresponder exatamente à palavra $test

De acordo com a página de documentação de Literais de String / Metacaracteres , eles são:

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

Também seria legal ter essa lista referenciada em algum lugar no código, mas não sei onde isso poderia estar ...

Combinando o que todos disseram, proponho o seguinte, para manter a lista de caracteres especiais para RegExp claramente listados em sua própria String e para evitar ter que tentar analisar visualmente milhares de "\\" 's. Isso parece funcionar muito bem para mim:

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

Na sugestão de @Sorin dos documentos do Java Pattern, parece que os caracteres para escapar são pelo menos:

\.[{(*+?^$|

O Pattern.quote(String s)tipo de faz o que você quer. No entanto, deixa um pouco a desejar; na verdade não escapa os caracteres individuais, apenas envolve a string com \Q...\E.

Não existe um método que faça exatamente o que você está procurando, mas a boa notícia é que é bastante simples escapar de todos os caracteres especiais em uma expressão regular Java:

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

Por que isso funciona? Bem, a documentação para Patterndiz especificamente que é permitido escapar caracteres não alfabéticos que não necessariamente precisam ser escapados:

É um erro usar uma barra invertida antes de qualquer caractere alfabético que não denota uma construção de escape; eles são reservados para futuras extensões da linguagem de expressão regular. Uma barra invertida pode ser usada antes de um caractere não alfabético, independentemente de esse caractere ser parte de uma construção sem escape.

Por exemplo, ;não é um caractere especial em uma expressão regular. No entanto, se você escapar, Patternainda interpretará \;como ;. Aqui estão mais alguns exemplos:

• >torna-se o \>que é equivalente a>
• [torna-se o \[que é a forma escapada de[
• 8está parado 8.
• \)torna-se \\\)qual é as formas escapadas \e (concatenadas.

Observação: a chave é a definição de "não alfabético", que na documentação realmente significa caracteres "não palavra " ou caracteres fora do conjunto de caracteres[a-zA-Z_0-9] .

do outro lado da moeda, você deve usar regex "não-char" que se pareça com este se caracteres especiais = allChars - número - ABC - espaço no contexto do seu aplicativo.

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

embora a resposta seja para Java, mas o código pode ser facilmente adaptado a partir desta extensão Kotlin String que criei (adaptado daquele @brcolow fornecido):

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())
}

estampas \(\.\*\)

verifique-o em ação aqui https://pl.kotl.in/h-3mXZkNE

Supondo que você tenha e confie (para ser autoritário) a lista de caracteres de escape que a regex Java usa (seria bom se esses caracteres fossem expostos em algum membro da classe Pattern), você pode usar o seguinte método para escapar o caractere se for realmente necessário:

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

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