¿Existe una función RegExp.escape en Javascript?

Solo quiero crear una expresión regular a partir de cualquier cadena posible.

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

¿Hay un método incorporado para eso? Si no, ¿qué usa la gente? Ruby tiene RegExp.escape. No siento que necesite escribir el mío, debe haber algo estándar por ahí. ¡Gracias!

La función vinculada anteriormente es insuficiente. No puede escapar ^o $(inicio y final de la cadena), o -, que en un grupo de caracteres se usa para rangos.

Utiliza esta función:

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

Si bien puede parecer innecesario a primera vista, el escape -(así como ^) hace que la función sea adecuada para insertar caracteres de escape en una clase de caracteres, así como en el cuerpo de la expresión regular.

Escapar /hace que la función sea adecuada para caracteres de escape que se utilizarán en un literal JS regex para una evaluación posterior.

Como no hay inconveniente en escapar de ninguno de ellos, tiene sentido escapar para cubrir casos de uso más amplios.

Y sí, es un fracaso decepcionante que esto no sea parte del JavaScript estándar.

Para cualquiera que use lodash, desde v3.0.0 se incluye una función _.escapeRegExp :

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

Y, en el caso de que no desee requerir la biblioteca completa de lodash, ¡puede requerir solo esa función !

La mayoría de las expresiones aquí resuelven casos de uso específicos individuales.

Eso está bien, pero prefiero un enfoque de "siempre funciona".

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

Esto "escapará completamente" de una cadena literal para cualquiera de los siguientes usos en expresiones regulares:

• Inserción en una expresión regular. P.ejnew RegExp(regExpEscape(str))
• Inserción en una clase de personaje. P.ejnew RegExp('[' + regExpEscape(str) + ']')
• Inserción en el especificador de conteo entero. P.ejnew RegExp('x{1,' + regExpEscape(str) + '}')
• Ejecución en motores de expresión regular que no sean JavaScript.

Caracteres especiales cubiertos:

• -: Crea un rango de caracteres en una clase de caracteres.
• [/ ]: Inicia / finaliza una clase de caracteres.
• {/ }: Inicia / finaliza un especificador de numeración.
• (/ ): Inicia / finaliza un grupo.
• */ +/ ?: Especifica el tipo de repetición.
• .: Coincide con cualquier personaje.
• \: Escapa de caracteres e inicia entidades.
• ^: Especifica el inicio de la zona de coincidencia y niega la coincidencia en una clase de caracteres.
• $: Especifica el final de la zona coincidente.
• |: Especifica la alternancia.
• #: Especifica el comentario en el modo de espacio libre.
• \s: Ignorado en el modo de espacio libre.
• ,: Separa los valores en el especificador de numeración.
• /: Inicia o finaliza la expresión.
• :: Completa tipos de grupos especiales y parte de las clases de personajes de estilo Perl.
• !: Niega el grupo de ancho cero.
• </ =: Parte de las especificaciones de grupo de ancho cero.

Notas:

• /no es estrictamente necesario en ningún sabor de expresión regular. Sin embargo, protege en caso de que alguien (estremecimiento) lo haga eval("/" + pattern + "/");.
• , garantiza que si la cadena está destinada a ser un número entero en el especificador numérico, provocará correctamente un error de compilación RegExp en lugar de compilar en silencio incorrectamente.
• #, y \sno necesita ser escapado en JavaScript, pero sí en muchos otros sabores. Aquí se escapan en caso de que la expresión regular se pase luego a otro programa.

Si también necesita probar la expresión regular en el futuro contra posibles adiciones a las capacidades del motor de expresión regular de JavaScript, le recomiendo usar el más paranoico:

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

Esta función escapa a todos los caracteres, excepto aquellos explícitamente garantizados que no se utilizarán para la sintaxis en futuros sabores de expresiones regulares.

Para los verdaderamente interesados ​​en el saneamiento, considere este caso extremo:

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

Esto debería compilarse bien en JavaScript, pero no en otros sabores. Si tiene la intención de pasar a otro sabor, el caso nulo de s === ''debe verificarse de forma independiente, así:

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

La Guía de Mozilla Developer Network para expresiones regulares proporciona esta función de escape:

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

En el widget de autocompletado de jQueryUI (versión 1.9.1) usan una expresión regular ligeramente diferente (Línea 6753), aquí está la expresión regular combinada con el enfoque @bobince.

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

Nada debería evitar que escapes de todos los caracteres no alfanuméricos:

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

Pierdes un cierto grado de legibilidad al hacerlo, re.toString()pero ganas mucha simplicidad (y seguridad).

De acuerdo con ECMA-262, por un lado, la expresión "caracteres de sintaxis" regulares son siempre no alfanumérico, tal que el resultado es seguro, y secuencias de escape especiales ( \d, \w, \n) siempre son alfanuméricos de tal manera que no se producirán fugas de control falsos .

Hay una propuesta de ES7 para RegExp.escape en https://github.com/benjamingr/RexExp.escape/ , con un polyfill disponible en https://github.com/ljharb/regexp.escape .

Esta es una versión más corta.

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

Esto incluye los caracteres que no son de meta %, &, ', y ,, aunque la especificación JavaScript RegExp lo permite.

XRegExp tiene una función de escape:

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

Más en: http://xregexp.com/api/#escape

En lugar de solo caracteres de escape que causarán problemas en su expresión regular (por ejemplo: una lista negra), ¿por qué no considerar usar una lista blanca? De esta manera, cada personaje se considera contaminado a menos que coincida.

Para este ejemplo, suponga la siguiente expresión:

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

Esto incluye letras blancas, números y espacios:

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

Devoluciones:

"be \|\| \! be"

Esto puede escapar de los personajes que no es necesario escapar, pero esto no obstaculiza su expresión (quizás algunas penalizaciones menores de tiempo, pero vale la pena por seguridad).

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

Las funciones en las otras respuestas son excesivas para escapar de expresiones regulares enteras (pueden ser útiles para escapar de partes de expresiones regulares que luego se concatenarán en expresiones regulares más grandes).

Si escapar de una expresión regular entero y terminado con él, citando a los meta-caracteres que son o independiente ( ., ?, +, *, ^, $, |, \) o iniciar algo ( (, [, {) es todo lo que necesita:

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

Y sí, es decepcionante que JavaScript no tenga una función como esta incorporada.

Otro enfoque (mucho más seguro) es escapar de todos los caracteres (y no solo de algunos especiales que conocemos actualmente) utilizando el formato de 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}'

Tenga en cuenta que debe pasar la ubandera para que este método funcione:

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

Solo ha habido y habrá 12 metacaracteres que deben escaparse
para considerarse literal.

No importa lo que se haga con la cadena escapada, insertada en una
envoltura de expresiones regulares equilibrada , añadida, no importa.

Haga un reemplazo de cadena usando esto

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