Esiste una funzione RegExp.escape in Javascript?

Voglio solo creare un'espressione regolare da qualsiasi possibile stringa.

var usersString = "Hello?!*`~World()[]";
var expression = new RegExp(RegExp.escape(usersString))
var matches = "Hello".match(expression);

Esiste un metodo integrato per quello? In caso contrario, cosa usano le persone? Ha Ruby RegExp.escape. Non mi sento di dover scrivere il mio, ci deve essere qualcosa di standard là fuori. Grazie!

La funzione collegata sopra non è sufficiente. Non riesce a fuggire ^o $(inizio e fine della stringa) o -, che in un gruppo di caratteri viene utilizzato per gli intervalli.

Usa questa funzione:

function escapeRegex(string) {
    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}

Mentre a prima vista può sembrare superfluo, l'escaping -(così come ^) rende la funzione adatta a caratteri di escape da inserire in una classe di caratteri e nel corpo della regex.

L' /escaping rende la funzione adatta a caratteri di escape da usare in un regex letterale JS per l'eval successivo.

Dato che non c'è alcun aspetto negativo nel fuggire da entrambi, ha senso scappare per coprire casi d'uso più ampi.

E sì, è un deludente fallimento che questo non faccia parte di JavaScript standard.

Per chiunque usi lodash, poiché v3.0.0 è integrata una funzione _.escapeRegExp :

_.escapeRegExp('[lodash](https://lodash.com/)');
// → '\[lodash\]\(https:\/\/lodash\.com\/\)'

E, nel caso in cui non si desideri richiedere la libreria lodash completa, è possibile richiedere proprio quella funzione !

La maggior parte delle espressioni qui risolve singoli casi d'uso specifici.

Va bene, ma preferisco un approccio "sempre funzionante".

function regExpEscape(literal_string) {
    return literal_string.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\\$&');
}

Ciò "sfuggirà completamente" a una stringa letterale per uno dei seguenti usi nelle espressioni regolari:

• Inserimento in un'espressione regolare. Per esempionew RegExp(regExpEscape(str))
• Inserimento in una classe di caratteri. Per esempionew RegExp('[' + regExpEscape(str) + ']')
• Inserimento nello specificatore del numero intero. Per esempionew RegExp('x{1,' + regExpEscape(str) + '}')
• Esecuzione in motori di espressione regolare non JavaScript.

Personaggi speciali coperti:

• -: Crea un intervallo di caratteri in una classe di caratteri.
• [/ ]: Avvia / termina una classe di caratteri.
• {/ }: Avvia / termina un identificatore di numerazione.
• (/ ): Avvia / termina un gruppo.
• */ +/ ?: Specifica il tipo di ripetizione.
• .: Corrisponde a qualsiasi personaggio.
• \: Consente di sfuggire ai caratteri e di avviare entità.
• ^: Specifica l'inizio della zona di corrispondenza e annulla la corrispondenza in una classe di caratteri.
• $: Specifica la fine della zona corrispondente.
• |: Specifica l'alternanza.
• #: Specifica il commento in modalità di spaziatura libera.
• \s: Ignorato in modalità di spaziatura libera.
• ,: Separa i valori nell'identificatore di numerazione.
• /: Avvia o termina l'espressione.
• :: Completa tipi di gruppo speciali e parte delle classi di caratteri in stile Perl.
• !: Nega il gruppo di larghezza zero.
• </ =: Parte delle specifiche del gruppo di larghezza zero.

Appunti:

• /non è strettamente necessario in nessun tipo di espressione regolare. Tuttavia, protegge in caso qualcuno (brivido) fa eval("/" + pattern + "/");.
• , assicura che se la stringa deve essere un numero intero nello specificatore numerico, causerà correttamente un errore di compilazione RegExp invece di una compilazione silenziosa errata.
• #e \snon è necessario eseguire l'escape in JavaScript, ma in molti altri gusti. Vengono salvati qui nel caso in cui l'espressione regolare venga successivamente passata a un altro programma.

Se hai anche bisogno di rendere l'espressione regolare a prova di futuro contro potenziali aggiunte alle funzionalità del motore regex di JavaScript, ti consiglio di usare il più paranoico:

function regExpEscapeFuture(literal_string) {
    return literal_string.replace(/[^A-Za-z0-9_]/g, '\\$&');
}

Questa funzione sfugge a tutti i caratteri ad eccezione di quelli esplicitamente garantiti che non possono essere utilizzati per la sintassi nei futuri gusti di espressioni regolari.

Per gli appassionati di servizi igienico-sanitari, considera questo caso limite:

var s = '';
new RegExp('(choice1|choice2|' + regExpEscape(s) + ')');

Questo dovrebbe compilare bene in JavaScript, ma non in alcuni altri gusti. Se si intende passare a un altro sapore, il caso nullo di s === ''deve essere verificato in modo indipendente, in questo modo:

var s = '';
new RegExp('(choice1|choice2' + (s ? '|' + regExpEscape(s) : '') + ')');

La Guida alle espressioni regolari della rete di sviluppatori Mozilla fornisce questa funzione di escape:

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

Nel widget di completamento automatico di jQueryUI (versione 1.9.1) usano una regex leggermente diversa (Linea 6753), ecco l'espressione regolare combinata con l'approccio @bobince.

RegExp.escape = function( value ) {
     return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
}

Nulla dovrebbe impedirti di sfuggire a ogni carattere non alfanumerico:

usersString.replace(/(?=\W)/g, '\\');

Perdi un certo grado di leggibilità quando lo fai, re.toString()ma vinci molta semplicità (e sicurezza).

Secondo ECMA-262, da un lato, regolare espressione "personaggi sintassi" sono sempre non alfanumerico, tale che il risultato sia sicura, e le sequenze di escape ( \d, \w, \n) sono sempre alfanumerico tali che non ci siano perdite di controllo falsi saranno prodotte .

Esiste una proposta ES7 per RegExp.escape su https://github.com/benjamingr/RexExp.escape/ , con un polyfill disponibile su https://github.com/ljharb/regexp.escape .

Questa è una versione più breve.

RegExp.escape = function(s) {
    return s.replace(/[$-\/?[-^{|}]/g, '\\$&');
}

Questo include i caratteri non-meta di %, &, ', e ,, ma la specifica JavaScript RegExp consente questo.

XRegExp ha una funzione di escape:

XRegExp.escape('Escaped? <.>'); // -> 'Escaped\?\ <\.>'

Maggiori informazioni su: http://xregexp.com/api/#escape

Invece di sfuggire solo ai personaggi che causeranno problemi nella tua espressione regolare (ad esempio: una lista nera), perché non prendere in considerazione l'uso di una whitelist. In questo modo ogni personaggio è considerato contaminato a meno che non corrisponda.

Per questo esempio, assumere la seguente espressione:

RegExp.escape('be || ! be');

Questo autorizza le lettere, il numero e gli spazi:

RegExp.escape = function (string) {
    return string.replace(/([^\w\d\s])/gi, '\\$1');
}

Ritorna:

"be \|\| \! be"

Questo può sfuggire ai personaggi che non hanno bisogno di essere sfuggiti, ma ciò non ostacola la tua espressione (forse alcune penalità di tempo minori - ma ne vale la pena per sicurezza).

escapeRegExp = function(str) {
  if (str == null) return '';
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

Le funzioni nelle altre risposte sono eccessive per sfuggire a intere espressioni regolari (possono essere utili per sfuggire a parti di espressioni regolari che verranno successivamente concatenate in regexps più grandi).

Se si sfuggire una intera espressione regolare e finito con essa, citando i metacaratteri che sono o standalone ( ., ?, +, *, ^, $, |, \) o inizia qualcosa ( (, [, {) è tutto ciò che serve:

String.prototype.regexEscape = function regexEscape() {
  return this.replace(/[.?+*^$|({[\\]/g, '\\$&');
};

E sì, è deludente che JavaScript non abbia una funzione come questa integrata.

Un altro approccio (molto più sicuro) è quello di sfuggire a tutti i personaggi (e non solo a quelli speciali che attualmente conosciamo) usando il formato di escape unicode \u{code}:

function escapeRegExp(text) {
    return Array.from(text)
           .map(char => `\\u{${char.charCodeAt(0).toString(16)}}`)
           .join('');
}

console.log(escapeRegExp('a.b')); // '\u{61}\u{2e}\u{62}'

Si noti che è necessario passare il uflag per far funzionare questo metodo:

var expression = new RegExp(escapeRegExp(usersString), 'u');

Ci sono sempre stati e ci saranno mai 12 meta personaggi che devono essere evasi
per essere considerati letterali.

Non importa cosa viene fatto con la stringa di escape, inserita in un
wrapper regex bilanciato , aggiunto, non importa.

Sostituisci usando una stringa usando questo

var escaped_string = oldstring.replace( /[\\^$.|?*+()[{]/g, '\\$&' );