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

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

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

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

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

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

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

Выход из {{} — это функция в подпрограмме обработчика / Использование toLocaleString ()

Это будет «выражение функции стрелки», введенное в ECMAScript 6.

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

Для тех, кто использует lodash, начиная с версии 3.0.0 a _. EscapeRegExp встроенная функция:

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

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

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

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

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

Что самое простое безбиблиотечный код для реализации пересечения массивов в JavaScript? Я хочу написать пересечение & # xA ; & # xA ; ([1,2,3], [2,3 , 4,5]) & # xD ; & # xA ; и получите & # xA ; & # xA ; [2, 3]

  • javascript — jQuery Ajax File Upload new RegExp(regExpEscape(str))
  • Это была единственная вещь, с которой я когда-либо работал, после поиска различных способов в Интернете. Это грязная тема. Множество решений размещено по всему миру, и большинство из них НЕ работают. Это сработало для меня: new RegExp('[' regExpEscape(str) ']')
  • Вставка в спецификатор целого числа. Например. new RegExp('x{1,' regExpEscape(str) '}')
  • Выполнение в механизмах регулярных выражений, отличных от JavaScript.

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

  • -: создает диапазон символов в классе символов.
  • [ / ] Это старый вопрос, но некоторые новые технологии могут кому-то помочь.
  • { / } Использование объектов JSON для локального хранилища:
  • ( / ) non-enumerable
  • * / / ?: Указывает тип повторения.
  • . if
  • : экранирует символы и запускает объекты.
  • ^: указывает начало зоны сопоставления и запрещает сопоставление в классе символов.
  • $: Указывает конец соответствующей зоны.
  • |: Указывает на чередование.
  • #: указывает комментарий в режиме свободного пробела.
  • s: Игнорируется в режиме свободного пробела.
  • ,: разделяет значения в спецификаторе нумерации.
  • / связей от нуля
  • :: Завершает специальные типы групп и часть классов символов в стиле Perl.
  • ! Теперь вам просто нужно указать имя файла в порядке World.js, чтобы использовать эти функции
  • < /=. Код, который передается в

Примечания:

  • / не является строго обязательным в любой форме регулярного выражения. Тем не менее, он защищает в случае, если кто-то (shudder) разрешено быть самозакрывающимся eval("/" pattern "/"); Глядя на вывод
  • , Она предоставляет сценарии для обнаружения мобильных браузеров. на нескольких языках, одним из которых является JavaScript. Это может помочь вам с тем, что вы ищете.
  • # и 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) : '')   ')');

может сделать только

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

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

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

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

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

Согласно ECMA-262, с одной стороны, регулярные выражения «синтаксические символы» всегда не алфавитно-цифровые, так что результат является безопасным и специальные escape-последовательности (re.toString(), но вы выиграли много простоты (и безопасности).

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

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

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

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

Это может быть кому-то полезно …

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

Подробнее о: .

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

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

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

Моя модель:

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

Возвраты:

"be || ! be"

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

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

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

Если вы избегаете целого регулярного выражения и с ним покончено, цитируете метасимволы, которые либо автономны (., ?, , *, ^, $, |, ) или начните что-то ((, [, { Ошибка VirtualBox

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

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