Existe uma função RegExp.escape em Javascript?

Eu só quero criar uma expressão regular a partir de qualquer string possível.

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

Existe um método embutido para isso? Se não, o que as pessoas usam? Ruby tem RegExp.escape. Eu não sinto que precisaria escrever o meu próprio, tem que haver algo padrão por aí. Obrigado!

A função vinculada acima é insuficiente. Falha ao escapar ^ou $(início e fim da string), ou -, que em um grupo de caracteres é usado para intervalos.

Use esta função:

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

Embora possa parecer desnecessário à primeira vista, o escape -(e também ^) torna a função adequada para caracteres de escape a serem inseridos em uma classe de caracteres, bem como no corpo do regex.

Escapando / escape torna a função adequada para caracteres de escape a serem usados ​​em um literal de regex JS para avaliação posterior.

Como não há desvantagem em escapar de um deles, faz sentido escapar para cobrir casos de uso mais amplos.

E sim, é uma falha decepcionante que isso não faça parte do JavaScript padrão.

Para quem usa o lodash, desde a v3.0.0, uma função _.escapeRegExp está integrada:

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

E, caso você não queira exigir a biblioteca completa do lodash, pode ser necessário apenas essa função !

A maioria das expressões aqui resolve casos de uso específicos únicos.

Tudo bem, mas eu prefiro uma abordagem "sempre funciona".

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

Isso "escapará totalmente" de uma cadeia literal para qualquer um dos seguintes usos em expressões regulares:

• Inserção em uma expressão regular. Por exemplonew RegExp(regExpEscape(str))
• Inserção em uma classe de caractere. Por exemplonew RegExp('[' + regExpEscape(str) + ']')
• Inserção no especificador de número inteiro. Por exemplonew RegExp('x{1,' + regExpEscape(str) + '}')
• Execução em mecanismos de expressão regular não JavaScript.

Caracteres Especiais Cobertos:

• -: Cria um intervalo de caracteres em uma classe de caracteres.
• [/ ]: Inicia / termina uma classe de personagem.
• {/ }: Inicia / termina um especificador de numeração.
• (/ ): Inicia / termina um grupo.
• */ +/ ?: Especifica o tipo de repetição.
• .: Corresponde a qualquer caractere.
• \: Ignora caracteres e inicia entidades.
• ^: Especifica o início da zona correspondente e nega a correspondência em uma classe de caracteres.
• $: Especifica o fim da zona correspondente.
• |: Especifica alternância.
• #: Especifica o comentário no modo de espaçamento livre.
• \s: Ignorado no modo de espaçamento livre.
• ,: Separa valores no especificador de numeração.
• /: Inicia ou termina a expressão.
• :: Conclui tipos de grupos especiais e parte de classes de caracteres no estilo Perl.
• !: Nega o grupo de largura zero.
• </ =: Parte das especificações do grupo de largura zero.

Notas:

• /não é estritamente necessário em qualquer sabor de expressão regular. No entanto, ele protege no caso de alguém (tremor) faz eval("/" + pattern + "/");.
• , garante que, se a string for um número inteiro no especificador numérico, ela causará corretamente um erro de compilação RegExp em vez de compilar incorretamente silenciosamente.
• #, e \snão precisa ser escapado em JavaScript, mas sim em muitos outros tipos. Eles são escapados aqui caso a expressão regular seja passada posteriormente para outro programa.

Se você também precisa proteger a expressão regular contra possíveis adições aos recursos do mecanismo de expressão regular JavaScript, recomendo usar o mais paranóico:

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

Essa função escapa de todos os caracteres, exceto aqueles explicitamente garantidos, que não serão utilizados para sintaxe em futuros sabores de expressões regulares.

Para quem realmente gosta de saneamento, considere este exemplo:

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

Isso deve compilar bem em JavaScript, mas não em outros tipos. Se pretender passar para outro sabor, o caso nulo de s === ''deve ser verificado independentemente, da seguinte forma:

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

O Guia de Expressões Regulares da Rede de Desenvolvedores da Mozilla fornece esta função de escape:

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

No widget de preenchimento automático do jQueryUI (versão 1.9.1), eles usam um regex ligeiramente diferente (Linha 6753), eis a expressão regular combinada com a abordagem @bobince.

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

Nada deve impedir você de escapar de todos os caracteres não alfanuméricos:

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

Você perde um certo grau de legibilidade ao fazê- re.toString()lo, mas ganha muita simplicidade (e segurança).

De acordo com ECMA-262, por um lado, de expressão "caracteres de sintaxe" regulares são sempre não-alfanumérico, de tal forma que o resultado é seguro e sequências de escape especiais ( \d, \w, \n) estão sempre alfanumérico, que será produzido não escapa de controle falsos .

Há uma proposta do ES7 para o RegExp.escape em https://github.com/benjamingr/RexExp.escape/ , com um polyfill disponível em https://github.com/ljharb/regexp.escape .

Esta é uma versão mais curta.

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

Isso inclui os não-caracteres meta de %, &, ', e ,, mas a especificação JavaScript RegExp permite isso.

XRegExp tem uma função de escape:

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

Mais sobre: http://xregexp.com/api/#escape

Em vez de apenas escapar caracteres que causam problemas em sua expressão regular (por exemplo: uma lista negra), por que não considerar usar uma lista de permissões. Dessa forma, cada personagem é considerado contaminado, a menos que corresponda.

Para este exemplo, assuma a seguinte expressão:

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

Esta lista de permissões inclui letras, número e espaços:

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

Devoluções:

"be \|\| \! be"

Isso pode escapar aos caracteres que não precisam ser escapados, mas isso não atrapalha sua expressão (talvez algumas pequenas penalidades de tempo - mas vale a pena por segurança).

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

As funções nas outras respostas são um exagero para escapar de expressões regulares inteiras (elas podem ser úteis para escapar partes de expressões regulares que serão posteriormente concatenadas em regexps maiores).

Se você escapar de uma expressão regular inteira e é feito com ele, citando os metacaracteres que são ou autônomo ( ., ?, +, *, ^, $, |, \) ou começar algo ( (, [, {) é tudo que você precisa:

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

E sim, é decepcionante que o JavaScript não tenha uma função como essa embutida.

Outra abordagem (muito mais segura) é escapar de todos os caracteres (e não apenas alguns especiais que atualmente conhecemos) usando o 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}'

Observe que você precisa passar a ubandeira para que este método funcione:

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

Só houve e sempre haverá 12 meta caracteres que precisam ser escapados
para serem considerados literais.

Não importa o que é feito com a cadeia de caracteres de escape, inserida em um
wrapper regex balanceado , anexado, não importa.

Substitua uma string usando este

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