Elenco di tutti i caratteri speciali che devono essere sottoposti a escape in una regex

Sto cercando di creare un'applicazione che corrisponda a un modello di messaggio con un messaggio che un utente sta tentando di inviare. Sto usando Java regex per abbinare il messaggio. Il modello / messaggio può contenere caratteri speciali.

Come posso ottenere l'elenco completo dei caratteri speciali di cui è necessario eseguire l'escape affinché la mia regex funzioni e corrisponda nel massimo dei casi possibili?

Esiste una soluzione universale per l'escape di tutti i caratteri speciali nella regex Java?

Puoi guardare il javadoc della classe Pattern: http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html

È necessario eseguire l'escape di qualsiasi carattere elencato lì se si desidera il carattere normale e non il significato speciale.

Come soluzione forse più semplice, puoi mettere il modello tra \ Q e \ E - tutto ciò che si trova tra di loro è considerato come sfuggito.

• I caratteri Java che devono essere sottoposti a escape nelle espressioni regolari sono:
  \.[]{}()<>*+-=!?^$|
• È necessario eseguire l'escape di due delle parentesi di chiusura ( ]e }) solo dopo aver aperto lo stesso tipo di parentesi.
• Tra []parentesi graffe alcuni caratteri (come +e -) a volte funzionano senza escape.

Per scappare potresti semplicemente usare questo da Java 1.5 :

Pattern.quote("$test");

Abbinerai esattamente la parola $test

Secondo la pagina di documentazione String Literals / Metacharacters , sono:

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

Inoltre sarebbe bello avere quella lista da qualche parte nel codice, ma non so dove potrebbe essere ...

Combinando ciò che tutti hanno detto, propongo quanto segue, per mantenere l'elenco dei caratteri speciali per RegExp chiaramente elencato nella propria stringa e per evitare di dover cercare di analizzare visivamente migliaia di "\\". Questo sembra funzionare abbastanza bene per me:

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

Su suggerimento di @ Sorin dei documenti di Java Pattern, sembra che i caratteri per sfuggire siano almeno:

\.[{(*+?^$|

Il Pattern.quote(String s) tipo di fa quello che vuoi. Tuttavia lascia un po 'a desiderare; in realtà non esegue l'escape dei singoli caratteri, si limita a avvolgere la stringa con \Q...\E.

Non esiste un metodo che faccia esattamente quello che stai cercando, ma la buona notizia è che in realtà è abbastanza semplice sfuggire a tutti i caratteri speciali in un'espressione regolare Java:

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

Perché funziona? Bene, la documentazione per Patternspecifica dice che è consentito eseguire l'escape di caratteri non alfabetici che non devono necessariamente essere sottoposti a escape:

È un errore utilizzare una barra rovesciata prima di qualsiasi carattere alfabetico che non denota un costrutto con escape; questi sono riservati per future estensioni al linguaggio delle espressioni regolari. È possibile utilizzare una barra rovesciata prima di un carattere non alfabetico indipendentemente dal fatto che quel carattere faccia parte di un costrutto senza caratteri di escape.

Ad esempio, ;non è un carattere speciale in un'espressione regolare. Tuttavia, se esegui l'escape, Patternverrà comunque interpretato \;come ;. Ecco alcuni altri esempi:

• >diventa \>che è equivalente a>
• [diventa \[che è la forma sfuggita di[
• 8è ancora 8.
• \)diventa \\\)che è le forme sfuggite \e (concatenate.

Nota: la chiave è la definizione di "non alfabetico", che nella documentazione significa in realtà caratteri "non parole " o caratteri al di fuori del set di caratteri [a-zA-Z_0-9].

sull'altro lato della medaglia, dovresti usare regex "non-char" che assomiglia a questo se caratteri speciali = allChars - numero - ABC - spazio nel contesto della tua app.

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

sebbene la risposta sia per Java, ma il codice può essere facilmente adattato da questa estensione Kotlin String che ho inventato (adattata da quella fornita da @brcolow):

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

stampe \(\.\*\)

controllalo in azione qui https://pl.kotl.in/h-3mXZkNE

Supponendo che tu abbia e ti fidi (per essere autorevole) dell'elenco dei caratteri di escape che Java utilizza (sarebbe carino se questi caratteri fossero esposti in qualche membro della classe Pattern) puoi usare il seguente metodo per eseguire l'escape del carattere se è effettivamente necessario:

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

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