test - ¿Hay una función RegExp.escape en Javascript?

regexp javascript

Question

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

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 deba escribir mi propia opinión, tiene que haber algo estándar por ahí. ¡Gracias!

Answer 1

En el widget 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, "//$&");
}

Answer 2

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

Para este ejemplo, asume la siguiente expresión:

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

Esta lista blanca letras, números y espacios:

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

Devoluciones:

"be /|/| /! be"

Esto puede escapar a los caracteres que no necesitan ser escapados, pero esto no obstaculiza su expresión (quizás algunas penalizaciones menores de tiempo, pero vale la pena por seguridad).

Answer 3

Esta es una versión más corta.

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

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

Answer 4

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 .

Answer 5

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

Utilice esta función:

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

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

Escape / hace que la función sea adecuada para los caracteres de escape que se utilizarán en un literal de expresiones regulares JS para su posterior evaluación.

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

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

Answer 6

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

Está bien, pero prefiero un enfoque "siempre funciona".

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

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

• Inserción en una expresión regular. Por ejemplo, new RegExp(regExpEscape(str))
• Inserción en una clase de personaje. Por ejemplo, new RegExp(''['' + regExpEscape(str) + '']'')
• Inserción en el especificador de conteo de enteros. Por ejemplo, new RegExp(''x{1,'' + regExpEscape(str) + ''}'')
• Ejecución en motores de expresiones regulares no JavaScript.

Personajes Especiales Cubiertos:

• - : crea un rango de caracteres en una clase de caracteres.
• [ / ] : Inicia / termina una clase de personaje.
• { / } : Inicia / finaliza un especificador de numeración.
• ( / ) : Inicia / termina un grupo.
• * / + / ? : Especifica el tipo de repetición.
• . : Coincide con cualquier personaje.
• / : Escapa de personajes, 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 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 termina la expresión.
• : Completa tipos de grupos especiales y parte de las clases de caracteres 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 (estremecedor) haga eval("/" + pattern + "/"); .
• , asegura que si se pretende que la cadena sea un número entero en el especificador numérico, causará correctamente un error de compilación RegExp en lugar de compilar de forma incorrecta el error.
• # , y /s no necesitan ser escapados en JavaScript, pero lo hacen en muchos otros sabores. Se escapan aquí en caso de que la expresión regular se pase luego a otro programa.

Si también necesita probar en el futuro la expresión regular frente a posibles adiciones a las capacidades del motor de expresiones regulares 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 a aquellos explícitamente garantizados, que no se usarán para la sintaxis en futuros tipos de expresiones regulares.

Para los verdaderos entusiastas del saneamiento, considere este caso de borde:

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 verificar de forma independiente, así:

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

Answer 7

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

Si se escapa de una expresión regular completa y termina con ella, citar los metacaracteres que son independientes ( . , ? , + , * , ^ , $ , | , / ) O comenzar 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 integrada.

Answer 8

Nada debe evitar que solo evites todos los caracteres no alfanuméricos:

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

Pierde un cierto grado de legibilidad cuando hace re.toString() pero gana mucha simplicidad (y seguridad).

Según ECMA-262, por un lado, la expresión regular "caracteres de sintaxis" es siempre no alfanumérica, de modo que el resultado es seguro, y las secuencias de escape especiales ( /d , /w , /n ) son siempre alfanuméricas de modo que no Se producirán falsos escapes de control.

Answer 9

Para cualquier persona que use lodash, desde v3.0.0 una función _.escapeRegExp está incorporada:

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

Y, en caso de que no quiera solicitar la biblioteca completa de lodash, ¡puede que necesite esa función !

Answer 10

XRegExp tiene una función de escape:

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

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

Answer 11

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

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

Answer 12

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