Существует ли функция RegExp.escape в Javascript?

Я просто хочу создать регулярное выражение из любой возможной строки.

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

Есть ли встроенный метод для этого? Если нет, что люди используют? Руби имеет RegExp.escape. Я не чувствую, что мне нужно писать свое, должно быть что-то стандартное. Спасибо!

Связанная выше функция недостаточна. Не удается избежать ^или $(начало и конец строки), или -, который в группе символов используется для диапазонов.

Используйте эту функцию:

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

Хотя это может показаться на первый взгляд ненужным, экранирование -(так же как и ^) делает функцию подходящей для экранирования символов, которые будут вставлены в класс символов, а также в тело регулярного выражения.

Экранирование /делает функцию подходящей для экранирования символов, которые будут использоваться в литерале регулярного выражения JS для последующего вычисления.

Так как нет побочных эффектов от побега любого из них, имеет смысл сбежать, чтобы охватить более широкие варианты использования.

И да, досадно, что это не является частью стандартного JavaScript.

Для тех , кто с помощью lodash, поскольку v3.0.0 _.escapeRegExp функция встроена в:

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

И, если вам не нужна полная библиотека lodash, вам может потребоваться только эта функция !

Большинство выражений здесь решают отдельные конкретные случаи использования.

Это нормально, но я предпочитаю подход "всегда работает".

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

Это «полностью экранирует» литеральную строку для любого из следующих применений в регулярных выражениях:

• Вставка в регулярное выражение. Напримерnew RegExp(regExpEscape(str))
• Вставка в класс персонажа. Напримерnew RegExp('[' + regExpEscape(str) + ']')
• Вставка в спецификатор целого числа. Напримерnew RegExp('x{1,' + regExpEscape(str) + '}')
• Выполнение в механизмах регулярных выражений не-JavaScript.

Охваченные специальные символы:

• -: Создает диапазон символов в классе символов.
• [/ ]: Запускает / заканчивает класс персонажа.
• {/ }: Запускает / заканчивает спецификатор нумерации.
• (/ ): Запускает / заканчивает группу.
• */ +/ ?: Определяет тип повторения.
• .: Соответствует любому персонажу.
• \: Экранирует персонажей и запускает сущности.
• ^: Определяет начало зоны сопоставления и отменяет сопоставление в классе символов.
• $: Указывает конец соответствующей зоны.
• |: Определяет чередование.
• #: Указывает комментарий в режиме свободного пробела.
• \s: Игнорируется в режиме свободного пространства.
• ,: Разделяет значения в спецификаторе нумерации.
• /: Начинается или заканчивается выражение.
• :: Завершает специальные типы групп и часть классов символов в стиле Perl.
• !: Отрицает группу нулевой ширины.
• </ =: Часть спецификации группы нулевой ширины.

Ноты:

• /не является строго необходимым в любом аромате регулярного выражения. Тем не менее, это защищает в случае, если кто-то (дрожь) делает eval("/" + pattern + "/");.
• , гарантирует, что если строка должна быть целым числом в числовом спецификаторе, она будет правильно вызывать ошибку компиляции RegExp вместо того, чтобы молча компилировать неправильно.
• #и \sне нужно экранировать в JavaScript, но делают во многих других вариантах. Они здесь экранированы на случай, если регулярное выражение будет позже передано другой программе.

Если вам также необходимо защитить регулярное выражение от потенциальных добавлений к возможностям механизма регулярных выражений JavaScript, я рекомендую использовать более параноидальный:

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

Эта функция экранирует все символы, кроме тех, которые явно гарантированно не будут использоваться для синтаксиса в будущих вариантах регулярных выражений.

Для истинных любителей санитарии рассмотрим этот крайний случай:

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

Это должно хорошо скомпилироваться в JavaScript, но не будет в некоторых других вариантах. Если вы намерены перейти к другому варианту, нулевой регистр s === ''должен быть проверен независимо, например, так:

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

Руководство по регулярным выражениям в Mozilla Developer Network предоставляет следующую функцию:

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

В виджете автозаполнения jQueryUI (версия 1.9.1) они используют немного другое регулярное выражение (строка 6753), вот регулярное выражение в сочетании с подходом @bobince.

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

Ничто не должно мешать вам просто экранировать все не алфавитно-цифровые символы:

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

Вы теряете определенную степень читабельности при выполнении, re.toString()но вы получаете большую простоту (и безопасность).

Согласно ECMA-262, с одной стороны, регулярное выражение «синтаксических символов» всегда не алфавитно-цифровой, так что результат является безопасным, и специальные управляющие последовательности ( \d, \w, \n) всегда алфавитно - цифровой , такие , что никакие ложные ускользает управления не будет производиться ,

Существует предложение ES7 для RegExp.escape по адресу https://github.com/benjamingr/RexExp.escape/ , а полифилл доступен по адресу https://github.com/ljharb/regexp.escape .

Это более короткая версия.

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

Это включает в себя не-мета - символы %, &, ', и ,, но спецификация JavaScript RegExp позволяет.

XRegExp имеет функцию escape:

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

Больше на: http://xregexp.com/api/#escape

Вместо того, чтобы экранировать только символы, которые вызовут проблемы в вашем регулярном выражении (например, черный список), почему бы не использовать вместо этого белый список. Таким образом, каждый персонаж считается испорченным, если он не совпадает.

Для этого примера предположим следующее выражение:

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

Это белый список букв, цифр и пробелов:

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

Возвращает:

"be \|\| \! be"

Это может скрывать символы, от которых не нужно убегать, но это не мешает вашему выражению (возможно, некоторые незначительные штрафы за время - но это стоит того для безопасности).

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

Функции в других ответах излишни для экранирования целых регулярных выражений (они могут быть полезны для экранирования частей регулярных выражений, которые впоследствии будут объединены в большие регулярные выражения).

Если вы бежите все регулярное выражение и сделали с ним, ссылаясь на метасимволы , которые являются либо автономными ( ., ?, +, *, ^, $, |, \) или начать что - то ( (, [, {) есть все , что вам нужно:

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

И да, разочаровывает то, что в JavaScript нет такой функции, как эта.

Другой (гораздо более безопасный) подход состоит в том, чтобы экранировать все символы (а не только несколько специальных, которые мы знаем в настоящее время), используя 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}'

Обратите внимание, что вам нужно передать uфлаг, чтобы этот метод работал:

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

Только когда-либо было и будет 12 метасимволов, которые нужно экранировать,
чтобы считаться литералом.

Неважно, что делается с экранированной строкой, вставленной в сбалансированную
оболочку регулярных выражений, с добавлением, не имеет значения.

Заменить строку, используя это

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