用多个其他字符串替换多个字符串

Posted

技术标签:

【中文标题】用多个其他字符串替换多个字符串【英文标题】：Replace multiple strings with multiple other strings 【发布时间】：2013-03-14 07:18:42 【问题描述】：

我正在尝试用多个其他单词替换字符串中的多个单词。字符串是“我有一只猫、一只狗和一只山羊。”

但是，这不会产生“我有一只狗、一只山羊和一只猫”，而是会产生“我有一只猫、一只猫和一只猫”。是否可以在 javascript 中同时，从而产生正确的结果？

var str = "I have a cat, a dog, and a goat.";
str = str.replace(/cat/gi, "dog");
str = str.replace(/dog/gi, "goat");
str = str.replace(/goat/gi, "cat");

//this produces "I have a cat, a cat, and a cat"
//but I wanted to produce the string "I have a dog, a goat, and a cat".

【问题讨论】：

我想用多个其他单词替换字符串中的多个单词，而不替换已经替换的单词。 我有一些不同的查询，如果我不知道用户要输入猫、狗或山羊怎么办（这是随机出现的）但每当出现这种词时，我需要替换为'动物'。如何得到这个场景 这个问题的最高投票答案似乎不正确：它有时会替换字符串 in the wrong order。 @AndersonGreen 在你的例子中为什么cat 不应该匹配catch 的cat 部分？您应该精确匹配标准。 @GuerricP 我需要尽可能匹配和替换每个字符串。在这种情况下，单词“catch”根本不匹配，因为单词“cat”首先出现在正则表达式中。 【参考方案1】：

具体解决方案

您可以使用一个函数来替换每个。

var str = "I have a cat, a dog, and a goat.";
var mapObj = 
   cat:"dog",
   dog:"goat",
   goat:"cat"
;
str = str.replace(/cat|dog|goat/gi, function(matched)
  return mapObj[matched];
);

jsfiddle example

概括它

如果您想动态维护正则表达式并只是将未来的交换添加到地图中，您可以这样做

new RegExp(Object.keys(mapObj).join("|"),"gi");

生成正则表达式。那么它看起来像这样

var mapObj = cat:"dog",dog:"goat",goat:"cat";

var re = new RegExp(Object.keys(mapObj).join("|"),"gi");
str = str.replace(re, function(matched)
  return mapObj[matched];
);

要添加或更改更多替换，您只需编辑地图即可。

fiddle with dynamic regex

使其可重复使用

如果您希望这是一个通用模式，您可以将其提取到这样的函数中

function replaceAll(str,mapObj)
    var re = new RegExp(Object.keys(mapObj).join("|"),"gi");

    return str.replace(re, function(matched)
        return mapObj[matched.toLowerCase()];
    );

那么你可以只将 str 和你想要的替换映射传递给函数，它会返回转换后的字符串。

fiddle with function

为确保 Object.keys 在旧版浏览器中有效，请添加一个 polyfill，例如来自 MDN 或 Es5。

【讨论】：

我不确定是否可以使用此函数来替换所有类型的字符串，因为 JavaScript 字符串中允许的字符与 JavaScript 标识符中允许的字符不同（例如作为此处使用的键）。 您可以使用任意字符串作为 javascript 属性。应该没关系。您不能对所有此类属性使用 . 表示法。括号符号适用于任何字符串。 确实很好用。我使用map='.': ',', ',': '.' 和正则表达式/\.|,/g 成功使用此解决方案（“特定”解决方案）将英文数字符号更改为欧洲数字符号（24,973.56 至 24.973,56）。 我喜欢这个解决方案，但我不得不将 return mapObj[matched.toLowerCase()]; 替换为 return mapObj[matched];，因为我在 mapObj 中使用了区分大小写的键。 您可能想要转义正则表达式的键：Object.keys(mapObj).map(key => key.replace(/[-\/\\^$*+?.()|[\]]/g, '\\$&')).join('|')。灵感来自this answer【参考方案2】：

作为回答：

寻找最新的答案

如果您在当前示例中使用“单词”，则可以使用非捕获组扩展 Ben McCormick 的答案，并在左侧和右侧添加单词边界 \b 以防止部分匹配。 

\b(?:cathy|cat|catch)\b
\b防止部分匹配的单词边界 (?:非捕获组 cathy|cat|catch 匹配其中一个选项 )关闭非捕获组 \b 防止部分匹配的单词边界

原始问题的示例：

let str = "I have a cat, a dog, and a goat.";
const mapObj = 
  cat: "dog",
  dog: "goat",
  goat: "cat"
;
str = str.replace(/\b(?:cat|dog|goat)\b/gi, matched => mapObj[matched]);
console.log(str);

cmets 中似乎运行不佳的示例示例：

let str = "I have a cat, a catch, and a cathy.";
const mapObj = 
  cathy: "cat",
  cat: "catch",
  catch: "cathy"

;
str = str.replace(/\b(?:cathy|cat|catch)\b/gi, matched => mapObj[matched]);
console.log(str);

【讨论】：

要使这个解决方案可重用，您可以define a function 使用地图对象替换字符串。【参考方案3】：

使用编号的项目以防止再次替换。 例如

let str = "I have a %1, a %2, and a %3";
let pets = ["dog","cat", "goat"];

然后

str.replace(/%(\d+)/g, (_, n) => pets[+n-1])

它是如何工作的：- %\d+ 查找 % 之后的数字。括号捕获数字。

这个数字（作为字符串）是 lambda 函数的第二个参数 n。

+n-1 将字符串转换为数字，然后减去 1 来索引 pets 数组。

%number 然后被替换为数组索引处的字符串。

/g 导致 lambda 函数被每个数字重复调用，然后用数组中的字符串替换。

在现代 JavaScript 中：-

replace_n=(str,...ns)=>str.replace(/%(\d+)/g,(_,n)=>ns[n-1])

【讨论】：

有趣。能否解释一下replace函数中的逻辑？ 这对于文本 I have a %11, a %21, and a %31 将无法正常工作，一旦我们需要最终结果 I have a dog1, a cat1, and a goat1。【参考方案4】：

在这种情况下，这可能无法满足您的确切需求，但我发现这是一种替换字符串中多个参数的有用方法，作为一种通用解决方案。它将替换参数的所有实例，无论它们被引用多少次：

String.prototype.fmt = function (hash) 
        var string = this, key; for (key in hash) string = string.replace(new RegExp('\\' + key + '\\', 'gm'), hash[key]); return string

您可以按如下方式调用它：

var person = 'title first last'.fmt( title: 'Agent', first: 'Jack', last: 'Bauer' );
// person = 'Agent Jack Bauer'

【讨论】：

这仅在您的密钥不包含任何特殊的正则表达式字符时才有效。否则，它将返回错误或更糟糕的情况，出现意外行为。例如：'abc'.fmt('a(b':1)【参考方案5】：

使用Array.prototype.reduce():

const arrayOfObjects = [
   plants: 'men' ,
   smart:'dumb' ,
   peace: 'war' 
]
const sentence = 'plants are smart'

arrayOfObjects.reduce(
  (f, s) => `$f`.replace(Object.keys(s)[0], s[Object.keys(s)[0]]), sentence
)

// as a reusable function
const replaceManyStr = (obj, sentence) => obj.reduce((f, s) => `$f`.replace(Object.keys(s)[0], s[Object.keys(s)[0]]), sentence)

const result = replaceManyStr(arrayOfObjects , sentence1)

示例 

// /////////////    1. replacing using reduce and objects

// arrayOfObjects.reduce((f, s) => `$f`.replace(Object.keys(s)[0], s[Object.keys(s)[0]]), sentence)

// replaces the key in object with its value if found in the sentence
// doesn't break if words aren't found

// Example

const arrayOfObjects = [
   plants: 'men' ,
   smart:'dumb' ,
   peace: 'war' 
]
const sentence1 = 'plants are smart'
const result1 = arrayOfObjects.reduce((f, s) => `$f`.replace(Object.keys(s)[0], s[Object.keys(s)[0]]), sentence1)

console.log(result1)

// result1: 
// men are dumb


// Extra: string insertion python style with an array of words and indexes

// usage

// arrayOfWords.reduce((f, s, i) => `$f`.replace(`$i`, s), sentence)

// where arrayOfWords has words you want to insert in sentence

// Example

// replaces as many words in the sentence as are defined in the arrayOfWords
// use python type 0, 1 etc notation

// five to replace
const sentence2 = '0 is 1 and 2 are 3 every 5'

// but four in array? doesn't break
const words2 = ['man','dumb','plants','smart']

// what happens ?
const result2 = words2.reduce((f, s, i) => `$f`.replace(`$i`, s), sentence2)

console.log(result2)

// result2: 
// man is dumb and plants are smart every 5

// replaces as many words as are defined in the array
// three to replace
const sentence3 = '0 is 1 and 2'

// but five in array
const words3 = ['man','dumb','plant','smart']

// what happens ? doesn't break
const result3 = words3.reduce((f, s, i) => `$f`.replace(`$i`, s), sentence3)

console.log(result3)

// result3: 
// man is dumb and plants

【讨论】：

最佳答案。但是有理由使用$f而不是f作为累加值吗？ 如果您想要替换所有给定的字符串，而不仅仅是第一个，请添加 g 标志：“const result1 = arrayOfObjects.reduce((f, s) => $f.replace (new RegExp(Object.keys(s)[0],'g'), s[Object.keys(s)[0]]), sentence1)"【参考方案6】：

这对我有用：

String.prototype.replaceAll = function(search, replacement) 
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
;

function replaceAll(str, map)
    for(key in map)
        str = str.replaceAll(key, map[key]);
    
    return str;


//testing...
var str = "bat, ball, cat";
var map = 
    'bat' : 'foo',
    'ball' : 'boo',
    'cat' : 'bar'
;
var new = replaceAll(str, map);
//result: "foo, boo, bar"

【讨论】：

Don't extend objects you don't own. 如果字符串包含正则表达式字符则不起作用。 关于“不要扩展...”：我扩展了我的字符串以比较两个字符串是否相等，不区分大小写。 String 不提供此功能，但可能有一天，这可能会导致我的应用程序崩溃。有没有办法“子类化”或“扩展”字符串以安全地包含这样的函数，或者我应该简单地定义一个新的两个参数函数作为我的应用程序库的一部分？【参考方案7】：

使用我的replace-once 包，您可以执行以下操作：

const replaceOnce = require('replace-once')

var str = 'I have a cat, a dog, and a goat.'
var find = ['cat', 'dog', 'goat']
var replace = ['dog', 'goat', 'cat']
replaceOnce(str, find, replace, 'gi')
//=> 'I have a dog, a goat, and a cat.'

【讨论】：

这个包太棒了 :) 完全符合我的预期 可惜这个包还可以replace the strings in the wrong order。 感谢@AndersonGreen 提醒我注意，我会解决的。【参考方案8】：

以防万一有人想知道为什么原始发帖人的解决方案不起作用：

var str = "I have a cat, a dog, and a goat.";

str = str.replace(/cat/gi, "dog");
// now str = "I have a dog, a dog, and a goat."

str = str.replace(/dog/gi, "goat");
// now str = "I have a goat, a goat, and a goat."

str = str.replace(/goat/gi, "cat");
// now str = "I have a cat, a cat, and a cat."

【讨论】：

【参考方案9】：

注意！

如果您使用的是动态提供的映射，这里的解决方案都不够用！

在这种情况下，有两种方法可以解决这个问题，（1）使用拆分连接技术，（2）使用带有特殊字符转义技术的正则表达式。

    这是一种拆分连接技术，比另一种快得多（至少快 50%）： 

var str = "I have abc a c|at, a d(og, and a g[oat] 1 7 11."
var mapObj = 
   'c|at': "d(og",
   'd(og': "g[oat",
   'g[oat]': "c|at",
;
var entries = Object.entries(mapObj);
console.log(
  entries
    .reduce(
      // Replace all the occurrences of the keys in the text into an index placholder using split-join
      (_str, [key], i) => _str.split(key).join(`$i`), 
      // Manipulate all exisitng index placeholder -like formats, in order to prevent confusion
      str.replace(/\(?=\d+\)/g, '-')
    )
    // Replace all index placeholders to the desired replacement values
    .replace(/\(\d+)\/g, (_,i) => entries[i][1])
    // Undo the manipulation of index placeholder -like formats
    .replace(/\-(?=\d+\)/g, '')
);
    这个是正则表达式特殊字符转义技术，它也有效，但慢得多： 

var str = "I have a c|at, a d(og, and a g[oat]."
var mapObj = 
   'c|at': "d(og",
   'd(og': "g[oat",
   'g[oat]': "c|at",
;
console.log(
  str.replace(
    new RegExp(
      // Convert the object to array of keys
      Object.keys(mapObj)
        // Escape any special characters in the search key
        .map(key => key.replace(/[-[\]()*+?.,\\^$|#\s]/g, '\\$&'))
        // Create the Regex pattern
        .join('|'), 
      // Additional flags can be used. Like `i` - case-insensitive search
      'g'
    ), 
    // For each key found, replace with the appropriate value
    match => mapObj[match]
  )
);

后者的优点是它还可以用于不区分大小写的搜索。

【讨论】：

什么是“动态提供的映射？” “动态提供的映射”是开发过程中key和value的未知内容，数量未知。这些信息大多在运行时就可以知道。例如。用户输入。 这主要是有效的，除了在某些情况下the keys overlap。如果正则表达式中的键按长度排序（从最长到最短），它可能会更好。 @AndersonGreen 是的，您可以按大小对其进行排序。但这实际上取决于您的用例。不过，有些人可能更喜欢先寻找最短的。在您的情况下，可以使用Object.keys(mapObj).sort((a,b) => b.length - a.length) 轻松解决【参考方案10】：

This solution 可以调整为仅替换整个单词 - 例如，在搜索“cat”时不会找到“catch”、“ducat”或“locator”。这可以通过在正则表达式中每个单词之前和之后的单词字符上使用负后瞻 (?<!\w) 和负前瞻 (?!\w) 来完成：

(?<!\w)(cathy|cat|ducat|locator|catch)(?!\w)

JSFiddle 演示：http://jsfiddle.net/mfkv9r8g/1/

【讨论】：

这在输入字符串包含特殊正则表达式字符的情况下不起作用：例如，参见here。您还需要转义这些字符。 是的，如果需要替换正则表达式中的特殊字符，您需要对其进行转义 - 例如 this 如果目标是替换 cat) - 不知道我理解为什么这是一个问题？【参考方案11】：

试试我的解决方案。随时改进

function multiReplace(strings, regex, replaces) 
  return str.replace(regex, function(x) 
    // check with replaces key to prevent error, if false it will return original value
    return Object.keys(replaces).includes(x) ? replaces[x] : x;
  );

var str = "I have a Cat, a dog, and a goat.";
//(json) use value to replace the key
var replaces = 
  'Cat': 'dog',
  'dog': 'goat',
  'goat': 'cat',

console.log(multiReplace(str, /Cat|dog|goat/g, replaces))

【讨论】：

【参考方案12】：

用户常规函数定义要替换的模式，然后使用替换函数处理输入字符串，

var i = new RegExp('"','g'),
    j = new RegExp('"','g'),
    k = data.replace(i,'').replace(j,'');

【讨论】：

如果你不知道跳过，但不要说这是错误的答案。我的案例 ""a":1,"b":2" 就是我用来替换上述方式的。如果它帮助其他人，如果他们想要其他人，那么答案不仅适合你。 @卡尔 再一次，你只是提供了一个毫无意义的答案，你所做的是提问者已经可以在问题中做的，这个答案会误导人们他们可能认为新的并且利用RegExp对象可以解决问题问题 这种情况下你做var i = new RegExp('','g'), j = new RegExp('','g'), k = data.replace(i,'').replace(j,'');的时候还是和asker的问题一样【参考方案13】： 
    var str = "I have a cat, a dog, and a goat.";

    str = str.replace(/goat/i, "cat");
    // now str = "I have a cat, a dog, and a cat."

    str = str.replace(/dog/i, "goat");
    // now str = "I have a cat, a goat, and a cat."

    str = str.replace(/cat/i, "dog");
    // now str = "I have a dog, a goat, and a cat."

【讨论】：

OP 询问“是否可以同时用多个其他字符串替换多个字符串”。这是三个独立的步骤。【参考方案14】：

您可以使用分隔符查找和替换字符串。

var obj = 
  'firstname': 'John',
  'lastname': 'Doe'


var text = "My firstname is firstname and my lastname is lastname"

alert(mutliStringReplace(obj,text))

function mutliStringReplace(object, string) 
      var val = string
      var entries = Object.entries(object);
      entries.forEach((para)=> 
          var find = '' + para[0] + ''
          var regExp = new RegExp(find,'g')
       val = val.replace(regExp, para[1])
    )
  return val;

【讨论】：

这是一个不同的问题。我想在不添加分隔符的情况下替换字符串。【参考方案15】： 我已修改 Ben McCormick's answer 以使用您的新测试用例。 我只是在正则表达式中添加了word boundaries： 
/\b(cathy|cat|catch)\b/gi

“运行代码sn-p”查看结果如下：

var str = "I have a cat, a catch, and a cathy.";
var mapObj = 
   cathy:"cat",
   cat:"catch",
   catch:"cathy"
;
str = str.replace(/\b(cathy|cat|catch)\b/gi, function(matched)
  return mapObj[matched];
);

console.log(str);

【讨论】：

除了添加单词边界之外，您还可以按长度对正则表达式中的字符串进行排序，以便首先匹配最长的字符串。 我认为你的答案是要走的路，但如果我是你，我会提供一种更通用的方法来做到这一点，以/\w+/g 作为模式，并使用一个函数返回匹配时您的对象中不存在该属性。另外，我认为 Map 更合适，而不是 standard 对象：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…。最后，toLowerCase() 或 toUpperCase() 的帮助会很有用。 @AndersonGreen 对字符串进行排序会得到稍微不同的结果。例如，“cats”将更改为“catchs”。单词边界将使“猫”完好无损。这取决于所需的行为。【参考方案16】： 
String.prototype.replaceSome = function() 
    var replaceWith = Array.prototype.pop.apply(arguments),
        i = 0,
        r = this,
        l = arguments.length;
    for (;i<l;i++) 
        r = r.replace(arguments[i],replaceWith);
    
    return r;

/* 字符串的 replaceSome 方法 它需要尽可能多的参数并替换所有 其中有我们指定的最后一个参数 2013 版权所有：Max Ahmed 这是一个例子：

var string = "[hello i want to 'replace x' with eat]";
var replaced = string.replaceSome("]","[","'replace x' with","");
document.write(string + "<br>" + replaced); // returns hello i want to eat (without brackets)

*/

jsFiddle：http://jsfiddle.net/CPj89/

【讨论】：

这并不能解决我的问题：它只会用另一个字符串替换几个字符串。【参考方案17】： 
<!DOCTYPE html>
<html>
<body>



<p id="demo">Mr Blue 
has a           blue house and a blue car.</p>

<button onclick="myFunction()">Try it</button>

<script>
function myFunction() 
    var str = document.getElementById("demo").innerHTML;
    var res = str.replace(/\n| |car/gi, function myFunction(x)

if(x=='\n')return x='<br>';
if(x==' ')return x='&nbsp';
if(x=='car')return x='BMW'
elsereturn x;//must need



);

    document.getElementById("demo").innerHTML = res;

</script>

</body>
</html>

【讨论】：

【参考方案18】：

我编写了这个 npm 包 stringinject https://www.npmjs.com/package/stringinject，它允许您执行以下操作

var string = stringInject("this is a 0 string for 1", ["test", "stringInject"]);

这会将 0 和 1 替换为数组项并返回以下字符串

"this is a test string for stringInject"

或者您可以使用对象键和值替换占位符，如下所示：

var str = stringInject("My username is username on platform",  username: "tjcafferkey", platform: "GitHub" );

"My username is tjcafferkey on Github"

【讨论】：

【参考方案19】：

您可以为此目的使用https://www.npmjs.com/package/union-replacer。它基本上是一个 string.replace(regexp, ...) 对应物，它允许一次进行多次替换，同时保留 string.replace(...) 的全部功能。

披露：我是作者。该库旨在支持更复杂的用户可配置替换，并解决了所有有问题的问题，例如捕获组、反向引用和回调函数替换。

上面的解决方案对于精确的字符串替换来说已经足够好了。

【讨论】：

【参考方案20】：

通过使用原型函数，我们可以通过传递带有键和值以及可替换文本的对象来轻松替换

String.prototype.replaceAll=function(obj,keydata='key')
 const keys=keydata.split('key');
 return Object.entries(obj).reduce((a,[key,val])=> a.replace(`$keys[0]$key$keys[1]`,val),this)


const data='hids dv sdc sd $yathin $ok'
console.log(data.replaceAll(yathin:12,ok:'hi','$key'))

【讨论】：

【参考方案21】：

所有解决方案都运行良好，除非应用于闭包的编程语言（例如 Coda、Excel、电子表格的 REGEXREPLACE）。

我的以下两个原始解决方案仅使用 1 个连接和 1 个正则表达式。

方法 #1：查找替换值

这个想法是如果替换值不在字符串中，则附加它们。然后，使用单个正则表达式，我们执行所有需要的替换：

var str = "I have a cat, a dog, and a goat.";
str = (str+"||||cat,dog,goat").replace(
   /cat(?=[\s\S]*(dog))|dog(?=[\s\S]*(goat))|goat(?=[\s\S]*(cat))|\|\|\|\|.*$/gi, "$1$2$3");
document.body.innerHTML = str;

解释：

cat(?=[\s\S]*(dog)) 表示我们在寻找“猫”。如果匹配，则正向查找会将“dog”捕获为组 1，否则捕获“”。 “狗”将“山羊”作为第 2 组捕获，“山羊”将“猫”作为第 3 组捕获。 我们替换为"$1$2$3"（所有三个组的串联），对于上述情况之一，它始终是“狗”、“猫”或“山羊” 如果我们像str+"||||cat,dog,goat" 这样手动将替换附加到字符串中，我们还会通过匹配\|\|\|\|.*$ 来删除它们，在这种情况下替换"$1$2$3" 将评估为“”，即空字符串。

方法 #2：查找替换对

方法 #1 的一个问题是它一次不能超过 9 个替换，这是反向传播组的最大数量。 方法 #2 声明不只是附加替换值，而是直接替换：

var str = "I have a cat, a dog, and a goat.";
str = (str+"||||,cat=>dog,dog=>goat,goat=>cat").replace(
   /(\b\w+\b)(?=[\s\S]*,\1=>([^,]*))|\|\|\|\|.*$/gi, "$2");
document.body.innerHTML = str;

解释：

(str+"||||,cat=&gt;dog,dog=&gt;goat,goat=&gt;cat") 是我们将替换映射附加到字符串末尾的方式。 (\b\w+\b) 声明“捕获任何单词”，可以替换为“(cat|dog|goat) 或其他任何单词。 (?=[\s\S]*...) 是一个正向查找，通常会一直到文档的末尾，直到替换映射之后。 ,\1=&gt; 表示“您应该在逗号和右箭头之间找到匹配的单词” ([^,]*) 表示“匹配此箭头之后的任何内容，直到下一个逗号或文档结尾” |\|\|\|\|.*$ 是我们移除替换地图的方式。

【讨论】：

【参考方案22】：

我们也可以使用 split() 和 join() 方法：

var str = "I have a cat, a dog, and a goat.";

str=str.split("cat").map(x => return x.split("dog").map(y => return y.split("goat").join("cat");).join("goat");).join("dog");

console.log(str);

【讨论】：

没有必要，因为我们只尝试替换字符串。拆分是不必要的步骤。【参考方案23】：

一种可能的解决方案是使用映射器表达式函数。

const regex = /(?:cat|dog|goat)/gmi;
const str = `I have a cat, a dog, and a goat.`;

let mapper = (key) => 
  switch (key) 
    case "cat":
      return "dog"
    case "dog":
      return "goat";
    case "goat":
      return "cat"
  

let result = str.replace(regex, mapper);

console.log('Substitution result: ', result);
//Substitution result1:  I have a dog, a goat, and a cat.

【讨论】：

【参考方案24】：

你可以试试这个。买不聪明。 

var str = "I have a cat, a dog, and a goat.";
console.log(str);
str = str.replace(/cat/gi, "XXX");
console.log(str);
str = str.replace(/goat/gi, "cat");
console.log(str);
str = str.replace(/dog/gi, "goat");
console.log(str);
str = str.replace(/XXX/gi, "dog");              
console.log(str);
输出： 我有一只狗，一只山羊和一只猫。

【讨论】：

【参考方案25】： 

const str = 'Thanks for contributing an answer to Stack Overflow!'
    const substr = ['for', 'to']

    function boldString(str, substr) 
        let boldStr
        boldStr = str
        substr.map(e => 
                const strRegExp = new RegExp(e, 'g');
                boldStr= boldStr.replace(strRegExp, `<strong>$e</strong>`);
            
        )
        return boldStr

【讨论】：

【参考方案26】：

我稍微扩展了@BenMcCormicks。他适用于常规字符串，但如果我有转义字符或通配符则不会。这就是我所做的

str = "[curl] 6: blah blah 234433 blah blah";
mapObj = '\\[curl] *': '', '\\d: *': '';


function replaceAll (str, mapObj) 

    var arr = Object.keys(mapObj),
        re;

    $.each(arr, function (key, value) 
        re = new RegExp(value, "g");
        str = str.replace(re, function (matched) 
            return mapObj[value];
        );
    );

    return str;


replaceAll(str, mapObj)

返回“blah blah 234433 blah blah”

这样它会匹配 mapObj 中的键而不是匹配的单词'

【讨论】：

//不值一提：replaceAll("我有一只猫、一只狗和一只山羊。", cat:"dog", dog:"goat", goat:"cat" ) / / 产生：“我有一只猫，一只猫，还有一只猫。”【参考方案27】：

Jquery 的解决方案（首先包含此文件）：将多个字符串替换为多个其他字符串：

var replacetext = 
    "abc": "123",
    "def": "456"
    "ghi": "789"
;

$.each(replacetext, function(txtorig, txtnew) 
    $(".eng-to-urd").each(function() 
        $(this).text($(this).text().replace(txtorig, txtnew));
    );
);

【讨论】：

这个解决方案需要 JQuery 吗？ javascript标签添加有问题，jquery是javascript的库。 @Super javascript tag added in question, and jquery is a libarary of javascript. 嗯，逻辑是关闭的，它应该是另一种方式，也只是提醒 - 来自 javascript 标签信息：“除非框架/库的另一个标签也包括在内，需要一个纯 JavaScript 答案。" @Anderson Green，是的，上面的脚本需要 jquery。 @Traxo，在大多数 Web 应用程序中，我们都使用框架（bootstrap/google 材料）。 Jquery 包含在所有现代框架中。因此，jquery 是 Web 应用程序的必备项。

以上是关于用多个其他字符串替换多个字符串的主要内容，如果未能解决你的问题，请参考以下文章

MySQL可以替换多个字符吗？

在不使用任何嵌套替换函数的情况下替换字符串中的多个字符

替换文件夹名称的多个字符

Linux批量替换多个文件中字符串

用一个值替换 Pandas 系列中的多个子字符串

用多个新字符串替换文件中特定位置的单个字符串