Come sfuggire all’espressione regolare in javascript?

Ho il codice come:

pattern = 'arrayname[1]'; // fetch from dom, make literal here just for example reg = new RegExp(RegExp.quote(pattern), 'g'); mystring.replace(reg, 'arrayname[2]'); 

ma non riesce con un messaggio di errore che dice: “RegExp.quote non è una funzione”.

Mi sto perdendo qualcosa di semplice?

Questa domanda mi ha portato a cercare su Google una funzione RegEx.quote in JavaScript, di cui non ero a conoscenza. Si scopre che la funzione esiste in un solo posto, vale a dire in una risposta di Gracenote qui su StackOverflow . La funzione è definita in questo modo:

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

Se si desidera utilizzare questa funzione, è necessario includere la definizione di cui sopra da qualche parte sopra il punto in cui si utilizza la funzione nel proprio script.

Dai documenti di sviluppo di Mozilla

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

Questo è fuori dall’ordinario, ma in questo particolare scenario creerei una funzione come questa

 RegExp.escape = function(str) { return String(str).replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"); }; 

uso

 new RegExp(RegExp.escape('http://www.google.com')); //=> /http\:\/\/www\.google\.com/ 

Se stai sostituendo letteralmente, non hai bisogno di regexp in primo luogo:

 str = str.split(search).join(replace) 
 var easiest = any_string.replace(/\W/g, "\\$&"); 

MODIFICARE:

Perché dovrei ricordare quali personaggi hanno un significato speciale o anche usare una funzione se è sufficiente l’escape di caratteri non di parole?

La mia soluzione è un gioco da ragazzi, forse è per questo che viene giù votato. : D

Ecco la funzione esatta utilizzata dalla libreria di chiusura di Google.

 /** * Escapes characters in the string that are not safe to use in a RegExp. * @param {*} s The string to escape. If not a string, it will be casted * to one. * @return {string} A RegExp safe, escaped copy of {@code s}. */ goog.string.regExpEscape = function(s) { return String(s).replace(/([-()\[\]{}+?*.$\^|,:#< !\\])/g, '\\$1'). replace(/\x08/g, '\\x08'); }; 

Vedi il link

Mozilla consiglia di utilizzare questa funzione per esplorare il carattere dalla regex:

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

Puoi trovare questo alla fine di questo capitolo nella Guida Javascript di Mozilla: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Using_Special_Characters

Le risposte precedenti sfuggono a troppi personaggi.

Secondo quali caratteri speciali devono essere sfuggiti nelle espressioni regolari? , devono essere sfuggiti solo i seguenti caratteri:

  • .^$*+?()[{\| classi di personaggi esterni.
  • ^-]\ all’interno delle classi di caratteri.

Quindi, questa funzione fa il trucco:

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

Bene, prima di tutto è ansible definire l’espressione regolare con una propria syntax costante:

 var reg = /arrayname\[1\]/; 

All’interno dell’espressione regolare si citano le cose con il backslash. Ora, se stai partendo da una stringa, devi “proteggere” quelle barre retroverse all’interno della costante di stringa. In tal caso, il pattern viene analizzato due volte : una volta quando la costante di stringa viene inghiottita dal parser di Javascript, e quindi una volta dal costruttore RegExp:

 var pattern = "arrayname\\[1\\]"; var reg = new RegExp(pattern); 

I backslash sono raddoppiati in modo che la stringa “pattern” assomigli all’espressione regolare nel mio primo esempio: una barra rovesciata prima di ogni carattere di parentesi.