Esiste una funzione RegExp.escape in Javascript?

Voglio solo creare un’espressione regolare da qualsiasi stringa ansible.

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

Esiste un metodo integrato per questo? In caso contrario, che cosa usano le persone? Ruby ha RegExp.escape . Non sento che avrei bisogno di scrivere il mio, ci dev’essere qualcosa di standard là fuori. Grazie!

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

Usa questa funzione:

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

Anche se può sembrare non necessario a prima vista, l’escape (e anche ^ ) rende la funzione adatta per l’escape di caratteri da inserire in una class di caratteri e anche nel corpo della regex.

Escaping / rende la funzione adatta per l’escape di caratteri da utilizzare in un regex JS letterale per la valutazione successiva.

Dal momento che non vi è alcun svantaggio per sfuggire a uno di essi, è logico scappare per coprire casi di utilizzo più ampi.

E sì, è un fallimento deludente che questo non faccia parte del codice 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 tu non voglia richiedere la libreria completa di lodash, potresti aver bisogno solo di quella funzione !

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

Va bene, ma preferisco un approccio “sempre funziona”.

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

Ciò "scappa completamente" una stringa letterale per uno qualsiasi dei seguenti usi nelle espressioni regolari:

  • Inserimento in un'espressione regolare. Ad esempio, new RegExp(regExpEscape(str))
  • Inserimento in una class di caratteri. Ad esempio, new RegExp('[' + regExpEscape(str) + ']')
  • Inserimento nello specificatore del numero intero. Es. new RegExp('x{1,' + regExpEscape(str) + '}')
  • Esecuzione in motori di espressioni regolari non JavaScript.

Caratteri speciali coperti:

  • - : Crea un intervallo di caratteri in una class di caratteri.
  • [ / ] : Avvia / termina una class di caratteri.
  • { / } : Avvia / termina un identificatore di numerazione.
  • ( / ) : Avvia / termina un gruppo.
  • * / + / ? : Specifica il tipo di ripetizione.
  • . : Corrisponde a qualsiasi personaggio.
  • \ : Escapes caratteri e inizia le quadro.
  • ^ : Specifica l'inizio della zona di corrispondenza e annulla la corrispondenza in una class di caratteri.
  • $ : Specifica la fine della zona di corrispondenza.
  • | : Specifica l'alternanza.
  • # : Specifica il commento nella modalità spaziatura libera.
  • \s : ignorato nella modalità spaziatura libera.
  • , : Separa i valori nello specificatore della numerazione.
  • / : Inizia o termina espressione.
  • : Completa tipi di gruppi speciali e parte di classi di caratteri in stile Perl.
  • ! : Nega il gruppo a larghezza zero.
  • < / = : Parte delle specifiche del gruppo con larghezza zero.

Gli appunti:

  • / non è strettamente necessario in qualsiasi sapore di espressione regolare. Tuttavia, protegge nel caso qualcuno (brivido) eval("/" + pattern + "/"); .
  • , assicura che se la stringa è intesa come un numero intero nello specificatore numerico, causerà correttamente un errore di compilazione di RegExp invece di compilare in modo errato la compilazione.
  • # , e \s non ha bisogno di essere sfuggito in JavaScript, ma in molti altri modi. Sono sfuggiti qui nel caso in cui l'espressione regolare verrà successivamente passata a un altro programma.

Se è necessario anche a prova di futuro l'espressione regolare contro potenziali aggiunte alle funzionalità del motore regex JavaScript, ti consiglio di utilizzare 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 devono essere utilizzati per la syntax in versioni future di espressioni regolari.


Per i veri professionisti dell'igienizzazione, considera questo caso limite:

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

Questo dovrebbe compilare bene in JavaScript, ma non in altri gusti. Se si intende passare ad un altro sapore, il caso nullo di s === '' dovrebbe essere controllato indipendentemente, in questo modo:

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

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

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

La Guida alle espressioni regolari di Mozilla Developer Network fornisce questa funzione di escape:

 function escapeRegExp(string){ return string.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1"); } 

Niente dovrebbe impedirti di sfuggire a ogni carattere non alfanumerico:

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

Si perde un certo grado di leggibilità quando si fa re.toString() ma si guadagna una grande quantità di semplicità (e sicurezza).

Secondo ECMA-262, da un lato, le espressioni regolari “caratteri di syntax” sono sempre non alfanumeriche, in modo tale che il risultato sia sicuro e le sequenze di escape speciali ( \d , \w , \n ) siano sempre alfanumeriche tali che no verranno prodotte false fughe di controllo.

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, '\\$&'); } 

Ciò include i caratteri non meta di % , & , ' , e,, ma la specifica RegExp JavaScript lo consente.

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

XRegExp ha una funzione di escape:

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

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

Piuttosto che solo caratteri di escape che causeranno problemi nell’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 whitelists lettere, numeri e 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 questo non ostacola la tua espressione (forse qualche penalità di tempo minore – ma ne vale la pena per sicurezza).

Le funzioni nelle altre risposte sono eccessive per l’escape di intere espressioni regolari (possono essere utili per eseguire l’escape di parti di espressioni regolari che verranno successivamente concatenate in espressioni regolari più grandi).

Se sfuggi a un’intera espressione regexp e hai finito, citando i metacaratteri che sono indipendenti ( . , ? , + , * , ^ , $ , | , \ ) O avvia qualcosa ( ( , [ , { ) è tutto ciò di cui hai bisogno :

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

E sì, è deludente che JavaScript non abbia una funzione come questo built-in.