Como você usa uma variável em uma expressão regular?

Gostaria de criar um String.replaceAll()método em JavaScript e estou pensando que usar um regex seria a maneira mais concisa de fazê-lo. No entanto, não consigo descobrir como passar uma variável para uma regex. Eu posso fazer isso já que irá substituir todas as instâncias de "B"com "A".

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

Mas eu quero fazer algo assim:

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

Mas, obviamente, isso substituirá apenas o texto "replaceThis"... então, como passo essa variável para minha string regex?

Em vez de usar a /regex/gsintaxe, você pode construir um novo objeto RegExp :

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

Você pode criar dinamicamente objetos regex dessa maneira. Então você fará:

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

Como Eric Wendelin mencionou, você pode fazer algo assim:

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

Isso gera "regex matching ." . No entanto, ele falhará se str1 for ".". Você esperaria que o resultado fosse "pattern matching regex", substituindo o período por "regex", mas acabará sendo ...

regexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregex

Isso ocorre porque, embora "."seja uma String, no construtor RegExp ainda é interpretado como uma expressão regular, significando qualquer caractere que não seja de quebra de linha, ou seja, todos os caracteres da string. Para esse fim, a seguinte função pode ser útil:

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

Então você pode fazer:

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

cedendo "pattern matching regex".

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

Como sempre: não use regex a menos que você precise. Para uma substituição simples de cadeia, o idioma é:

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

Então você não precisa se preocupar com os problemas de citação mencionados na resposta do Gracenotes.

Se você deseja obter TODAS as ocorrências ( g), faça distinção entre maiúsculas e minúsculas ( i) e use limites para que não seja uma palavra dentro de outra palavra ( \\b):

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

Exemplo:

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.

Para quem procura usar variável com o método match , isso funcionou para mim

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

Este:

var txt=new RegExp(pattern,attributes);

é equivalente a isso:

var txt=/pattern/attributes;

Consulte http://www.w3schools.com/jsref/jsref_obj_regexp.asp .

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

Você deseja construir a expressão regular dinamicamente e, para isso, a solução adequada é usar o new RegExp(string)construtor. Para que o construtor trate caracteres especiais literalmente , você deve escapar deles. Há uma função interna no widget de preenchimento automático da UI do jQuery chamada $.ui.autocomplete.escapeRegex:

[...] você pode fazer uso da $.ui.autocomplete.escapeRegexfunção embutida. Será necessário um único argumento de string e escapará a todos os caracteres regex, tornando o resultado seguro para passar new RegExp().

Se você estiver usando a interface do usuário do jQuery, poderá usar essa função ou copiar sua definição da fonte :

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

E use-o assim:

"[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");

Teste com esta ferramenta

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

Teste como:

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

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

Aqui está outra implementação 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;
    };

E a versão coffeescript da resposta de Steven Penny, já que este é o resultado # 2 do google .... mesmo que o café seja apenas javascript com muitos caracteres removidos ...;)

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

e no meu caso particular

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

Embora você possa criar RegExp criados dinamicamente (conforme as outras respostas a esta pergunta), repetirei meu comentário em um post semelhante : A forma funcional de String.replace () é extremamente útil e, em muitos casos, reduz a necessidade de objetos RegExp criados dinamicamente. (que é meio doloroso porque você precisa expressar a entrada para o construtor RegExp como uma sequência de caracteres, em vez de usar o formato literal de barras / [AZ] + / regexp)

Para satisfazer minha necessidade de inserir uma variável / alias / function em uma Expressão Regular, é isso que eu criei:

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

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

onde 'oldre' é o regexp original que eu quero inserir uma variável, 'xx' é o espaço reservado para essa variável / alias / function e 'yy' é o nome, o alias ou a função real da variável.

Você pode usar isso se $ 1 não funcionar com você

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

Você sempre pode usar indexOfrepetidamente:

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);
};

Isso não entra em um loop infinito quando a substituição contém a correspondência.

Sua solução está aqui:

Passe uma variável para expressão regular.

O que eu implementei é pegar o valor de um campo de texto que você deseja substituir e outro é o campo de texto "substituir por", obtendo o valor do campo de texto em uma variável e definindo a variável como RegExp função para substituir ainda mais. No meu caso, estou usando o Jquery, você também pode fazê-lo apenas com JavaScript.

Código 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));
  });

Este código está no evento Onclick de um botão, você pode colocar isso em uma função para chamar.

Então agora você pode passar variáveis ​​na função de substituição.

Essa função de auto-chamada itera sobre o substiterItems usando um índice e altera o substituerItems [index] globalmente na cadeia a cada passagem.

  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'

Nenhuma dessas respostas estava clara para mim. Acabei encontrando uma boa explicação em http://burnignorance.com/php-programming-tips/how-to-use-a-variable-in-replace-function-of-javascript/

A resposta simples é:

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

Por exemplo:

$("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>

Para substituição múltipla sem expressões regulares, fui com o seguinte:

      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

A parte importante da solução foi encontrada aqui