Javascript 如何在正则表达式中使用变量？
我想在JavaScript中创建一个String.replaceAll方法，我认为使用正则表达式是最简洁的方法。但是，我不知道如何将变量传递给正则表达式。我已经可以这样做了，它将用A替换B的所有实例 但我想这样做：Javascript 如何在正则表达式中使用变量？,javascript,regex,Javascript,Regex,我想在JavaScript中创建一个String.replaceAll方法，我认为使用正则表达式是最简洁的方法。但是，我不知道如何将变量传递给正则表达式。我已经可以这样做了，它将用A替换B的所有实例 但我想这样做： String.prototype.replaceAll = function(replaceThis, withThis) { this.replace(/replaceThis/g, withThis); }; str1 = "pattern" var re = new
String.prototype.replaceAll = function(replaceThis, withThis) {
this.replace(/replaceThis/g, withThis);
};
str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");
"[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]"
"mystring1".replace(re, "newstring");
var txt=/pattern/attributes;
请参阅。正如Eric Wendelin提到的，您可以执行以下操作：
String.prototype.replaceAll = function(replaceThis, withThis) {
this.replace(/replaceThis/g, withThis);
};
str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");
"[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]"
regexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregex
RegExp.quote = function(str) {
return str.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
};
str1 = "."
var re = new RegExp(RegExp.quote(str1), "g");
"pattern matching .".replace(re, "regex");
生成模式匹配正则表达式。虽然您可以根据对该问题的其他回答生成动态创建的正则表达式，但我将回应a中的评论：的函数形式非常有用，在许多情况下减少了对动态创建的正则表达式对象的需要。这是一种痛苦，因为您必须将RegExp构造函数的输入表示为字符串，而不是使用斜杠/[a-Z]+/RegExp文本格式 ABABAB.replace/B/g，A 和往常一样：除非必须，否则不要使用正则表达式。对于简单的字符串替换，习惯用法是：
'ABABAB'.split('B').join('A')
String.prototype.replaceAll = function (replaceThis, withThis) {
var re = new RegExp(replaceThis,"g");
return this.replace(re, withThis);
};
var aa = "abab54..aba".replaceAll("\\.", "v");
使用此测试对于任何希望使用匹配方法的变量的人来说，这对我来说很有效
var alpha = 'fig';
'food fight'.match(alpha + 'ht')[0]; // fight
下面是另一个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;
};
为了满足在正则表达式中插入变量/别名/函数的需要，我提出了以下建议：
oldre = /xx\(""\)/;
function newre(e){
return RegExp(e.toString().replace(/\//g,"").replace(/xx/g, yy), "g")
};
String.prototype.replaceAll = this.replace(newre(oldre), "withThis");
“yy”是实际的变量名、别名或函数。如果$1不能使用，您可以使用它
var pattern = new RegExp("amman","i");
"abc Amman efg".replace(pattern,"<b>"+"abc Amman efg".match(pattern)[0]+"</b>");
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);
};
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("]", ">"))
您希望动态构建正则表达式，为此，正确的解决方案是使用新的RegExpstring构造函数。为了让构造函数按字面意思处理特殊字符，必须对其进行转义。在$.ui.autocomplete.escapeRegex中有一个内置函数： […]您可以使用内置的 $.ui.autocomplete.escapeRegex函数。只需要一根绳子 参数，并对所有正则表达式字符进行转义，使结果可以安全地保存 传递到新的RegExp 如果您使用的是jQuery UI，则可以使用该函数，或复制其定义： 然后像这样使用它：
String.prototype.replaceAll = function(replaceThis, withThis) {
this.replace(/replaceThis/g, withThis);
};
str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");
"[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]"
还有Steven Penny答案的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!"
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));
});
现在，您可以在replace函数中传递变量。如果要获取所有出现的g，请不区分大小写i，并使用边界，使其不是另一个单词中的单词\\b： 例如：
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.
这些答案我都不清楚。我最终在一次会议上找到了一个很好的解释 答案很简单：
var search_term = new RegExp(search_term, "g");
text = text.replace(search_term, replace_term);
单击“我”以获取不带正则表达式的多重替换我使用了以下内容：
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
此自调用函数将使用索引在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'
作为一个相对的JavaScript新手，我们注意到/赞赏公认的答案，但它不是很直观 这里有一个更简单的解释 例如，使用 myString='苹果派，香蕉面包'； console.logmyString.replaceAll/pie/gi，“pie” //苹果派，香蕉面包 console.logmyString.replaceAll/\bpie\b/gi，“派” //苹果派，香蕉面包 console.logmyString.replaceAll/pi/gi，“派” //苹果派，香蕉面包 console.logmyString.replaceAll/\bpi\b/gi，“派” //[无效]苹果派，香蕉面包 const match_word='pie'； console.logmyString.replaceAll/match_word/gi，**PIE** //[无效]苹果派，香蕉面包 console.logmyString.replaceAll/\b`${bmatch\u word}`\b/gi，**PIE** //[无效]苹果派，香蕉面包 // -------------------- // ... 新建RegExp：确保\-避开反斜杠：\b>\\b。。。 常量匹配项='pie'； const match\u re=new RegExp`\\b${match\u term}\\b`，'gi' console.logmyString.replaceAllmatch\u re“派” //苹果派，香蕉面包 console.logmyString.replacematch_re，**PIE** //苹果派，香蕉面包 console.logmyString.replaceAllmatch_re，**PIE** //苹果派，香蕉面包 应用 例如：替换字符串/句子中的颜色突出显示词，[可选]如果搜索词匹配的匹配词超过用户定义的比例 注：匹配项的原始字符大小写保留。hl：突出显示；re:regex |正则表达式 mySentence=苹果，书？书预定的。书签，书签，书签！收受赌注，香蕉；在…之前。 函数替换内容，hl\U术语，hl\U re{ console.log'mycentence[raw]：'，mycentence console.log'hl_term:'，hl_term'，hl_term.length:'，hl_term.length 截止值=hl_项长度； console.log'cutoff:'，cutoff //`.match`方便地收集多个匹配项 //将部分匹配包含到[数组] const hl_terms=mycentence.toLowerCase.matchl_re，hl_term； 如果hl_terms==null{ console.log“与hl_term'+hl_term+不匹配”；回显输入字符串，然后退出…' 回归自我； } console.log'hl_terms:'，hl_terms 对于let i=0；i
如果使用正确的语法传递变量，则可以使用下面的代码这样做 这还具有在同一变量中使用标志的额外好处 此外，当涉及到\w等时，您不必在regexp中双重转义 var str='regexVariable示例：这是我用regexVariable替换RegExp的示例 var reVar=/.*regex\w+？iable.+？/gi； var resStr=str.replacenew RegExpreVar，'$1:：$2:：：$3'； console.logresStr； //返回：
//：：：regexVariable:：：示例：这是我用一个：：：regexVariable:：：：：。您可以将字符串用作正则表达式，不要忘记使用新的RegExp 例如：
var yourFunction = new RegExp(
'^-?\\d+(?:\\.\\d{0,' + yourVar + '})?'
)
您知道，要替换的第一个参数可以是普通字符串，而不必是
正则表达式？str1=。；alertpattern matching..replacestr1，字符串@一些人：当然。这是因为上面的例子并不重要。当您需要搜索或替换与常规字符串组合的模式时，请执行str.matchnew RegExphttps？：//+RegExp.escapemyDomainName，例如。令人恼火的是，转义函数没有内置。另外，显然JC Grubbs需要一个全局替换；在使用String.replaceString实现全局替换时，对于较大的输入，String可能会比较慢。我只是说，前两个解决方案有缺陷，在某些输入上会意外失败。提供类似的函数，但它们排除-，并包括=！：/。正确的术语是转义，而不是引号。顺便说一句。如果你需要使用像/\/word\：\w*$/这样的表达式，一定要避开反斜杠：new RegExp'\\/word\：\\w*$。@gravityboy你可以做+myNumber.replace/10/g，'a'或者如果你想要十六进制数，你可以做parseInt+myNumber，16从十进制转换为十六进制。问题表明正则表达式仅用于替换常量字符串。所以这个答案是错误的，因为如果字符串包含正则表达式元字符，它将失败。不幸的是，它的投票率如此之高，会让人头疼……举个例子，通过一个变量，这将是一个很好的答案。读了这篇文章后，我仍在苦苦挣扎。@JonathanSwinney:：如果您从字符串构造正则表达式，则没有特殊意义，所以您不需要转义它/\/word\：\w*$/应该是新的RegExp'/word\\：\\w*$，您是否测量过它比regex快？这似乎更可取，尤其是当需要匹配特殊的regex字符时，如“.”嗯。。。不拆分也需要一个RegExp；如果是这样的话，会不会造成同样的问题？无论如何在某些平台上，split.join可能较慢，因为它是两个操作，而.replace是一个操作，可以进行优化。@PacMan-：split和replace都可以接受字符串或RegExp对象。replace的问题在于，当你使用一个字符串时，你只能得到一个替换。这里的基准测试：是的，但在第一个示例中，它使用模式作为变量，在第二个示例中，它使用模式作为字符串。注意，我们目前正在讨论，如果你对此有意见，请加入讨论。为什么要投反对票？coffeescript-IS-javascript具有自己的特定语法。robot.name=hubot不是javascript。您的replace_with variable将包含DOM元素，而不是其本身的值。如果您正在覆盖闭包变量，则无需在此处使用var。此外，如果通过\b或\1，它将中断。我喜欢这个答案，因为它不会创建额外的无意义变量。谢谢！afaict，您的是通过模板字符串显式使用Emacs/rx样式插值的唯一答案。在尝试了在正则表达式中插入变量的每个解决方案后，您的解决方案是唯一适用于我的解决方案。非常感谢你！