如何在正则表达式中使用变量？

Question

我想创建一个字符串.replaceAll（）方法，并认为使用正则表达式是最简洁的方法。然而，我不知道如何将变量传递到正则表达式中。我已经可以这样做了，这将取代的所有实例“B”具有“A”.

“ABABAB”.替换（/B/g，“A”）；

但我想这样做：

String.prototype.replaceAll=函数（replaceThis，withThis）{this.replace（/replaceThis/g，withThis）；};

但显然，这只会取代文本“替换此”…那么如何将此变量传递到正则表达式字符串中？

Answer 1

而不是使用/\sREGEX\s/g公司语法，您可以构造一个新的注册Exp对象：

//变量==“REGEX”let re=new RegExp（String.raw`\s${variable}\s`，“g”）；

您可以通过这种方式动态创建正则表达式对象。然后您将执行以下操作：

“mystring1”替换（re，“newstring”）；

对于较旧的浏览器或节点

//变量==“REGEX”var re=新RegExp（“\\s”+变量+“\\s“，”g“）；“mystring1”替换（re，“newstring”）；

Answer 2

正如埃里克·温德林所说，你可以这样做：

str1=“图案”var re=新RegExp（str1，“g”）；“模式匹配。”.replace（re，“regex”）；

这就产生了“正则表达式匹配。”。但是，如果str1为"."。你会期望结果是“模式匹配正则表达式”，将句点替换为“正则表达式”，但结果会是。。。

正则表达式regexregexregex正则表达式regex正则正则表达式regegxregexregExregexregexregexRegexregexRegex正则表达式

这是因为，尽管"."是一个字符串，在RegExp构造函数中，它仍被解释为正则表达式，表示任何非换行字符，表示字符串中的每个字符。为此，以下函数可能有用：

RegExp.quote=函数（str）{return str.replace（/（[.？*+^$[\]\\（）｛｝|-]）/g，“\\$1”）；};

然后您可以执行以下操作：

str1=“.”var re=新RegExp（RegExp.quote（str1），“g”）；“模式匹配。”.replace（re，“regex”）；

顺从的“模式匹配正则表达式”.

Answer 3

“ABABAB”.替换（/B/g，“A”）；

一如既往：除非必须，否则不要使用正则表达式。对于简单的字符串替换，习惯用法是：

“ABABAB”。拆分（“B”）。联接（“A”）

这样你就不用担心Gracenotes的答案中提到的引用问题了。

Answer 4

如果你想得到全部的个事件(克)，不区分大小写(我)，并使用边界，使其不是另一个单词中的单词(\\b条):

re=新RegExp（`\\b${replaceThis}\\b`，'gi'）；

---

让inputString=“我是John，或者johnny，但我更喜欢John。”；let replaceThis=“约翰”；let re=new RegExp（`\\b$｛replaceThis｝\\b`，'gi'）；console.log（inputString.replace（re，“Jack”））；

Answer 5

这个：

var txt=新RegExp（模式、属性）；

等于：

var txt=/pattern/attributes；

请参见http://www.w3schools.com/jsref/jsref_obj_regexp.asp.

Answer 6

对于希望将变量与比赛方法，这对我很有效：

var alpha=“图”；“食物大战”。match（alpha+'ht'）[0]；//战斗

Answer 7

this.replace（new RegExp（replaceThis，'g'），withThis）；

Answer 8

您需要动态构建正则表达式您必须使用新RegExp（字符串）带转义的构造函数.

中有一个内置函数jQuery UI自动完成小部件打电话$.ui.autocomplete.escapeRegex（$.ui.自动完成.escapeRegex）:

它将使用单个字符串参数并转义所有正则表达式字符，将结果安全传递给新RegExp（）.

如果不使用jQuery UI，可以复制其定义从源头:

函数escapeRegex（值）{返回值.replace（/[\-\[\]{}（）*+\\\^$|#\s] /g，“\\$&”）；}

并按如下方式使用：

“[z-a][z-a][z-a]”.replace（新RegExp（escapeRegex（“[z-a]”），“g”），”[a-z]“）；//escapeRegex（“[z-a]”）->“\[z\-a\]”//新RegExp（escapeRegex（“[z-a]”），“g”）->/\[z\-a\]/g//最终结果->“[a-z][a-z][a-z]”

Answer 9

String.prototype.replaceAll=函数（replaceThis，withThis）{var re=新RegExp（replaceThis，“g”）；return this.替换（re，用this）；};var aa=“abab54..aba”.replaceAll（“\\.”，“v”）；

用这个测试工具

Answer 10

String.prototype.replaceAll=函数（a，b）{return this.replace（new RegExp（a.replace）（/（[.？*+^$[\]\\（）{}|-]）/ig，“\\$1”），'ig'），b）}

测试方式如下：

var whatever='[b]句子中的一些[b]随机[/b]文本。[/b]“console.log（whatever.replaceAll（“[”，“<”）.replace All（”]“，”>“））

Answer 11

可以将字符串用作正则表达式。别忘了使用新RegExp.

例子：

var yourFunction=新RegExp('^-?\\d+（？：\\.\\d{0，'+yourVar+'}）？')

Answer 12

为了满足我在正则表达式中插入变量/别名/函数的需要，我想出了以下方法：

oldre=/xx\（“”\）/；函数newre（e）{return RegExp（e.toString（）.replace（/\//g，“”）.replay（/xx/g，yy），“g”）};String.prototype.replaceAll=this.replace（newre（oldre），“withThis”）；

其中“oldre”是我要插入变量的原始regexp，“xx”是该变量/别名/函数的占位符，“yy”是实际的变量名、别名或函数。

Answer 13

以及CoffeeScript版本的史蒂文·彭尼的回答，因为这是第二个谷歌搜索结果。。。。即使CoffeeScript只是删除了许多字符的JavaScript…；）

baz=“foo”过滤器=新RegExp（baz+“d”）“食物大战”匹配（过滤器）[0]//食物

在我的特殊情况下：

robot.name=hubotfilter=新RegExp（robot.name）if msg.match.input.match（过滤器）console.log“真的！”

Answer 14

这里是另一个replaceAll实现：

String.prototype.replaceAll=函数（stringToFind，stringToReplace）{if（stringToFind==stringToReplace）返回此值；var温度=此；var index=临时索引（字符串查找）；while（索引！=-1）{temp=临时替换（字符串查找，字符串替换）；index=临时indexOf（字符串到查找）；}返回温度；};

Answer 15

如果$1不适合您：

var pattern=新RegExp（“amman”，“i”）；“abc Amman efg”替换（模式，“<b>”+“abc Amman efg“.match（模式）[0]+”</b>“）；

Answer 16

虽然您可以动态创建RegExp（根据对此问题的其他回答），但我将在类似职位：的功能形式字符串.replace（）非常有用，在许多情况下可以减少对动态创建的RegExp对象的需要。（这有点麻烦，因为您必须将RegExp构造函数的输入表示为字符串，而不是使用斜杠/[a-Z]+/RegExp文本格式）

Answer 17

这个自调用函数将使用索引迭代replacerItems，并在每次传递时全局更改字符串上的replaceerItems[index]。

const replacerItems=[“a”，“b”，“c”]；函数替换器（str，index）{const item=replacerItems[索引]；const regex=新RegExp（`[${item}]`，“g”）；const newStr=str.replace（regex，“z”）；if（索引<replacerItems.length-1）{返回替换器（newStr，索引+1）；}返回newStr；}//console.log（replacer（'abcdefg'，0））将输出'zzzdefg'

Answer 18

这些答案我都不清楚。我最终在如何在JavaScript的replace函数中使用变量

简单的答案是：

var search_term=新RegExp（search_tterm，“g”）；text=text.replace（search_term，replace_term）；

例如：

$（“按钮”）.点击（函数（）{Find_and_replace（“Lorem”，“Chocolate”）；Find_and_replace（“ipsum”，“冰淇淋”）；});函数Find_and_replace（搜索项，替换项）{text=$（“textbox”）.html（）；var search_term=新RegExp（search_tterm，“g”）；text=text.replace（搜索_term，替换_term）；$（“textbox”）.html（文本）；}

<script src=“https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js“></script>＜文本框＞Lorem ipsum洛雷姆ipsum</textbox>单击我

Answer 19

我在这里和stackoverflow或类似论坛上的其他公开门票中找到了很多带有奇怪例子的答案。

在我看来，这是最简单的选项，可以将变量作为模板文字字符串；

const someString=“abc”；const regex=新RegExp（`^someregex${someString}someregex$`）；

正如您所看到的，我没有在开头或结尾使用正斜杠，RegExp构造函数将重新构造有效的正则表达式文字。与yup匹配功能一起使用。

Answer 20

你可以随时使用索引属于重复：

String.prototype.replaceAll=函数（子字符串，替换）{var结果=“”；var lastIndex=0；while（真）{var index=this.indexOf（substring，lastIndex）；如果（指数===-1）中断；结果+=this.substring（lastIndex，index）+替换；lastIndex=索引+子字符串长度；}return result+this.substring（lastIndex）；};

当替换包含匹配时，这不会进入无限循环。

Answer 21

一种实现方法是从要替换的文本字段和“替换为”文本字段中获取值，从变量中的文本字段获取值，并将变量设置为RegExp函数以进行进一步替换。在我的例子中，我使用的是jQuery，但您也可以只通过JavaScript来实现。

JavaScript代码：

var replace=document.getElementById（“replace}”）；//使用“我想替换”从文本字段中获取值var replace_with=document.getElementById（“with”）//从要替换另一个字符串的其他文本字段中获取值。var sRegExInput=新RegExp（替换，“g”）；$（“body”）.children（）.each（function（）{$（this）.html（$（this）.html（）.replace（sRegExInput，replace_with））；});

此代码位于按钮的Onclick事件上，您可以将其放入要调用的函数中。

现在可以在replace函数中传递一个变量。

Answer 22

示例：regex以开头

函数startWith（char，value）{return new RegExp（`^[${char}]`，'gi'）.test（value）；}

Answer 23

如果有其他人在找这个，下面是您如何保留操作员的方法：

//坏让foo=“foo”新RegExp（`${foo}\s`，“g”）；//=>/foos/g//很好让foo=“foo”新RegExp（`${foo}${/\s/.source}`，“g”）；//=>/foo\s/g

Answer 24

简单方法：

String.prototype.replaceAll=函数（replaceThis，withThis）{const regexp=新regexp（`${replaceThis}`，'g'）；this.replace（regexp，with this）；};

Answer 25

对于不带正则表达式的多重替换，我使用了以下方法：

let str=“我是猫人。我喜欢猫”；let find=“cat”；let replace=“dog”；//统计要查找的字符串的出现次数//在待检查的str内部。让findCount=str.split（find）.length-1；让loopCount=0；while（循环计数<查找计数）{str=str.replace（查找、替换）；loopCount=循环计数+1；}  console.log（str）；//我是个养狗的人。我喜欢狗

解决方案的重要部分就在这里

Answer 26

如果您使用正确的语法传递变量，那么您可以使用下面的代码这样做。

这还具有在同一变量中使用标志的额外好处。

而且你不必双重逃跑\在正则表达式中\w个等。

var str='regexVariable示例：这是我的RegExp替换为regexVaVariable的示例。'var reVar=/（.*？）（正则表达式\w+？able）（.+？）/gi；var resStr=str.replace（新RegExp（reVar），'$1:）：）$2:）：）；console.log（resStr）；//退货：//：）：：）：）regexVariable:）：）示例：这是我的RegExp替换为a：）：。

OP示例中的原型版本：

var str='regexVariable prototype:This is my example of RegExp replacement with a regexVaiable。'String.prototype.regexVariable=函数（reFind，reReplace）{return str.replace（新RegExp（reFind），reReplace）；}var reVar=/（.*？）（正则表达式\w+？able）（.+？）/gi；console.log（str.regexVariable（reVar，'$1:）：）$2:）：）；//退货：//：）：：）：）regexVariable:）：）：。

Answer 27

作为JavaScript的相对新手，公认的答案是https://stackoverflow.com/a/494046/1904943值得注意/欣赏，但这不是很直观。

下面是一个简单的解释，通过示例（使用简单JavaScript IDE).

myString='苹果派，香蕉面包'；console.log（myString.replaceAll（/pie/gi，'pie'））//苹果馅饼、香蕉面包console.log（myString.replaceAll（/\bpie\b/gi，'PIE'））//苹果馅饼、香蕉面包console.log（myString.replaceAll（/pi/gi，'PIE'））//苹果馅饼、香蕉面包console.log（myString.replaceAll（/\bpi\b/gi，'PIE'））//[无效]苹果派、香蕉面包const match_word='pie'；console.log（myString.replaceAll（/match_word/gi，'**PIE**'））//[无效]苹果派、香蕉面包console.log（myString.replaceAll（/\b`${bmatch_word}`\b/gi，'**PIE**'））//[无效]苹果派、香蕉面包// ----------------------------------------// ... new RegExp（）：请务必转义反斜杠：\b>>\\b。。。const match_term=“饼图”；const match_re=新RegExp（`（\\b${match_term}\\b）`，'gi'）console.log（myString.replaceAll（match_re，'PiE'））//苹果馅饼、香蕉面包console.log（myString.replace（match_re，'**PIE**'））//苹果**馅饼**，香蕉面包console.log（myString.replaceAll（match_re，'**PIE**'））//苹果**馅饼**，香蕉面包

应用程序

例如：如果搜索词匹配的匹配词超过用户定义的比例，则替换字符串/句子中的单词（颜色突出显示），[可选]。

注：保留匹配术语的原始字符大小写。高浓度：突出显示；重新：正则表达式|正则表达式

mySentence=“苹果，boOk？BOoks；booKEd.BookMark，'BookmarkeD'，bOOkmarks！bookmakingG，香蕉；bE，BeEn，beFore。”函数替换器（mySentence，hl_term，hl_re）{console.log（'mySentence[raw]：'，mySentence）控制台.log（'hl_term:'，hl_term，'|hl_term.length:'，hl_term.longth）cutton=hl_term.length；console.log（'自动关闭：'，切断）//`.match（）`方便地收集多个匹配项//（包括部分匹配）到[数组]中const hl_terms=mySentence.toLowerCase（）.match（hl_re，hl_term）；if（hl_terms==空）{console.log（'与hl_term“'+hl_term+'”不匹配；回显输入字符串然后退出…'）return mySentence；}控制台.log（'hl_terms:'，hl_terms）for（设i=0；i<hl_terms.length；i++）{console.log（“----------------------------------------”）console.log（'['+i+']：'，hl_terms[i]，'|length:'，hl_terms[i].length，'|parseInt（0.7（length））：'，parseInt（0.7*hl_terms[i].length））//测试：如果（hl_terms[i].length>=截止*10）{if（cuttop>=parseInt（0.7*hl_terms[i].length））{var match_term=hl_terms[i].toString（）；console.log（'匹配项：'，match_term，'[截止长度：'，cuttop，'|0.7（匹配项长度）：'，parseInt（0.7*hl_terms[i].length））const match_re=新RegExp（`（\\b${match_term}\\b）`，'gi'）mySentence=mySentence.replaceAll（match_re，'<font style=“background:#ffe74e”>$1</font>'）；}其他{var match_term=hl_terms[i].toString（）；console.log（'NO match:'，match_term，'[截断长度：'，截断，'|0.7（匹配项长度）：'，parseInt（0.7*hl_terms[i].length））}}return mySentence；}//测试：//const hl_term='be'；//const hl_term='bee'；//const hl_term=“之前”；//const hl_term='book'；const hl_term='bookma'；//const hl_term=“莱布尼茨”；//此正则表达式从单词开头匹配：const hl_re=新RegExp（`（\\b${hl_term}[A-z]*）\\b`，'gi'）mySentence=替换器（mySentense，hl_term，hl_re）；console.log（'mySentence[已处理]：'，mySentence）

输出

苹果，好吗？书；布克。书签，“BookmarkeD”，血迹！图书制作，香蕉；bE、BeEn、beFore。hl_term:bookma | hl_term.长度：6截止：6hl_terms:数组（4）[“bookmark”，“bookmarked”，“书签”，“Bookmarksmaking”]----------------------------------------[0]：书签|长度：8|parseInt（0.7（长度））：5匹配术语：书签[截止长度：6|0.7（匹配术语长度）：5----------------------------------------[1] ：书签|长度：10|parseInt（0.7（长度））：7无匹配：已添加书签[截止长度：6|0.7（匹配术语长度）：7----------------------------------------[2] ：书签|长度：9 | parseInt（0.7（长度））：6匹配术语：书签[截止长度：6|0.7（匹配术语长度）：6----------------------------------------[3] ：bookmaking |长度：10 | parseInt（0.7（长度））：7无匹配：博彩[截止长度：6|0.7（匹配期限长度）：7苹果，好吗？书；布克。书签，'BookmarkeD'，bOOkmarks</font>！图书制作，香蕉；bE、BeEn、beFore。

Answer 28

引入ECMAScript 2021全部替换.

以前，要替换全部的在目标字符串中出现纯字符串时，通常传递正则表达式（带有克修饰符）作为参数代替方法，因为传递字符串as-is只会替换该字符串的第一次出现。

自ECMAScript 2021以来，如果目标是替换全部的目标字符串中出现的纯字符串。

Answer 29

当有一个更简单的答案仍然可以使用正则表达式完成工作时，所有这些答案看起来都非常复杂。

String.prototype.replaceAll=函数（replaceThis，withThis）{const-expr=`${replaceThis}`this.replace（new RegExp（expr，“g”），用this）；};

解释

这个注册Exp构造函数有两个参数：表达式和标志。通过在表达式中使用模板字符串，我们可以将变量传递到类中，并将其转换为/（replaceThis变量的值）/g.