Как вы используете переменную в регулярном выражении?

Я хотел бы создать String.replaceAll()метод в JavaScript, и я думаю, что использование регулярных выражений было бы наиболее кратким способом сделать это. Однако я не могу понять, как передать переменную в регулярное выражение. Я могу сделать это уже, что заменит все экземпляры "B"с "A".

"ABABAB".replace(/B/g, "A");

Но я хочу сделать что-то вроде этого:

String.prototype.replaceAll = function(replaceThis, withThis) {
    this.replace(/replaceThis/g, withThis);
};

Но очевидно, что это заменит только текст "replaceThis"... как мне передать эту переменную в мою строку регулярного выражения?

Вместо использования /regex/gсинтаксиса вы можете создать новый объект RegExp :

var replace = "regex";
var re = new RegExp(replace,"g");

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

"mystring".replace(re, "newstring");

Как упоминал Эрик Венделин, вы можете сделать что-то вроде этого:

str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");

Это дает "regex matching .". Тем не менее, он потерпит неудачу, если str1 ".". Вы ожидаете, что результат будет "pattern matching regex", заменив период на "regex", но он окажется ...

regexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregex

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

 RegExp.quote = function(str) {
     return str.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
 };

Тогда вы можете сделать:

str1 = "."
var re = new RegExp(RegExp.quote(str1), "g");
"pattern matching .".replace(re, "regex");

уступая "pattern matching regex".

"ABABAB".replace(/B/g, "A");

Как всегда: не используйте регулярные выражения, если нет необходимости. Для простой замены строки используется идиома:

'ABABAB'.split('B').join('A')

Тогда вам не нужно беспокоиться о проблемах цитирования, упомянутых в ответе Gracenotes.

Если вы хотите получить ВСЕ вхождения ( g), учитывайте регистр ( i) и используйте границы, чтобы это слово не входило в другое слово ( \\b):

re = new RegExp(`\\b${replaceThis}\\b`, 'gi');

Пример:

let inputString = "I'm John, or johnny, but I prefer john.";
let replaceThis = "John";
let re = new RegExp(`\\b${replaceThis}\\b`, 'gi');
console.log(inputString.replace(re, "Jack")); // I'm Jack, or johnny, but I prefer Jack.

Для тех, кто хочет использовать переменную с методом match , это сработало для меня

var alpha = 'fig';
'food fight'.match(alpha + 'ht')[0]; // fight

Эта:

var txt=new RegExp(pattern,attributes);

эквивалентно этому:

var txt=/pattern/attributes;

См. Http://www.w3schools.com/jsref/jsref_obj_regexp.asp .

this.replace( new RegExp( replaceThis, 'g' ), withThis );

Вы хотите построить регулярное выражение динамически, и для этого правильным решением является использование new RegExp(string)конструктора. Чтобы конструктор обрабатывал специальные символы буквально , вы должны избегать их. Там является встроенной функцией в JQuery UI автозаполнения виджет под названием $.ui.autocomplete.escapeRegex:

[...] вы можете использовать встроенную $.ui.autocomplete.escapeRegexфункцию. Он принимает единственный строковый аргумент и экранирует все символы регулярного выражения, что делает результат безопасным для передачи new RegExp().

Если вы используете пользовательский интерфейс jQuery, вы можете использовать эту функцию или скопировать ее определение из источника :

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

И используйте это так:

"[z-a][z-a][z-a]".replace(new RegExp(escapeRegex("[z-a]"), "g"), "[a-z]");
//            escapeRegex("[z-a]")       -> "\[z\-a\]"
// new RegExp(escapeRegex("[z-a]"), "g") -> /\[z\-a\]/g
// end result                            -> "[a-z][a-z][a-z]"

String.prototype.replaceAll = function (replaceThis, withThis) {
   var re = new RegExp(replaceThis,"g"); 
   return this.replace(re, withThis);
};
var aa = "abab54..aba".replaceAll("\\.", "v");

Тест с этим инструментом

String.prototype.replaceAll = function(a, b) {
    return this.replace(new RegExp(a.replace(/([.?*+^$[\]\\(){}|-])/ig, "\\$1"), 'ig'), b)
}

Проверьте это как:

var whatever = 'Some [b]random[/b] text in a [b]sentence.[/b]'

console.log(whatever.replaceAll("[", "<").replaceAll("]", ">"))

Вот еще одна замена replaceAll:

    String.prototype.replaceAll = function (stringToFind, stringToReplace) {
        if ( stringToFind == stringToReplace) return this;
        var temp = this;
        var index = temp.indexOf(stringToFind);
        while (index != -1) {
            temp = temp.replace(stringToFind, stringToReplace);
            index = temp.indexOf(stringToFind);
        }
        return temp;
    };

И версия ответа Стивена Пенни, написанная coffeescript, так как это результат №2 в Google .... даже если кофе - это просто javascript с удалением большого количества символов ...;)

baz = "foo"
filter = new RegExp(baz + "d")
"food fight".match(filter)[0] // food

и в моем конкретном случае

robot.name=hubot
filter = new RegExp(robot.name)
if msg.match.input.match(filter)
  console.log "True!"

Хотя вы можете создавать динамически создаваемые RegExp (как и другие ответы на этот вопрос), я повторю свой комментарий из аналогичного поста : функциональная форма String.replace () чрезвычайно полезна и во многих случаях уменьшает потребность в динамически создаваемые объекты RegExp. (что является своего рода болью, потому что вы должны выразить входные данные для конструктора RegExp в виде строки, а не использовать литеральный формат слешей / [AZ] + / regexp)

Чтобы удовлетворить мою потребность вставить переменную / псевдоним / функцию в регулярное выражение, вот что я придумал:

oldre = /xx\(""\)/;
function newre(e){
    return RegExp(e.toString().replace(/\//g,"").replace(/xx/g, yy), "g")
};

String.prototype.replaceAll = this.replace(newre(oldre), "withThis");

где 'oldre' - это исходное регулярное выражение, в которое я хочу вставить переменную, 'xx' - это заполнитель для этой переменной / псевдонима / функции, а 'yy' - это фактическое имя переменной, псевдоним или функция.

Вы можете использовать это, если $ 1 не работает с вами

var pattern = new RegExp("amman","i");
"abc Amman efg".replace(pattern,"<b>"+"abc Amman efg".match(pattern)[0]+"</b>");

Вы всегда можете использовать indexOfповторно:

String.prototype.replaceAll = function(substring, replacement) {
    var result = '';
    var lastIndex = 0;

    while(true) {
        var index = this.indexOf(substring, lastIndex);
        if(index === -1) break;
        result += this.substring(lastIndex, index) + replacement;
        lastIndex = index + substring.length;
    }

    return result + this.substring(lastIndex);
};

Это не входит в бесконечный цикл, когда замена содержит совпадение.

Ваше решение здесь:

Передайте переменную в регулярное выражение.

То, что я реализовал, - это взятие значения из текстового поля, которое вы хотите заменить, а другое - текстовое поле «заменить на», получение значения из текстового поля в переменной и присвоение переменной значения RegExp. функция для дальнейшей замены. В моем случае я использую Jquery, вы также можете сделать это только с помощью JavaScript.

Код JavaScript:

  var replace =document.getElementById("replace}"); // getting a value from a text field with I want to replace
  var replace_with = document.getElementById("with"); //Getting the value from another text fields with which I want to replace another string.

  var sRegExInput = new RegExp(replace, "g");    
  $("body").children().each(function() {
    $(this).html($(this).html().replace(sRegExInput,replace_with));
  });

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

Теперь вы можете передать переменную в функцию замены.

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

  const replacerItems = ["a", "b", "c"];    

    function replacer(str, index){
          const item = replacerItems[index];
          const regex = new RegExp(`[${item}]`, "g");
          const newStr = str.replace(regex, "z");
          if (index < replacerItems.length - 1) {
            return replacer(newStr, index + 1);
          }
          return newStr;
    }

// console.log(replacer('abcdefg', 0)) will output 'zzzdefg'

Ни один из этих ответов не был мне понятен. В конце концов я нашел хорошее объяснение на http://burnignorance.com/php-programming-tips/how-to-use-a-variable-in-replace-function-of-javascript/

Простой ответ:

var search_term = new RegExp(search_term, "g");    
text = text.replace(search_term, replace_term);

Например:

$("button").click(function() {
  Find_and_replace("Lorem", "Chocolate");
  Find_and_replace("ipsum", "ice-cream");
});

function Find_and_replace(search_term, replace_term) {
  text = $("textbox").html();
  var search_term = new RegExp(search_term, "g");
  text = text.replace(search_term, replace_term);
  $("textbox").html(text);
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<textbox>
  Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum
</textbox>
<button>Click me</button>

Для множественной замены без регулярных выражений я пошел со следующим:

      let str = "I am a cat man. I like cats";
      let find = "cat";
      let replace = "dog";


      // Count how many occurrences there are of the string to find 
      // inside the str to be examined.
      let findCount = str.split(find).length - 1;

      let loopCount = 0;

      while (loopCount < findCount) 
      {
        str = str.replace(find, replace);
        loopCount = loopCount + 1;
      }  

      console.log(str);
      // I am a dog man. I like dogs

Важная часть решения была найдена здесь