Javascript 用多个其他字符串替换多个字符串_Javascript_Node.js_Regex_String_Replace

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

javascript node.js regex string replace

Javascript 用多个其他字符串替换多个字符串,javascript,node.js,regex,string,replace,Javascript,Node.js,Regex,String,Replace,我正在尝试用多个其他单词替换字符串中的多个单词。字符串是“我有一只猫，一只狗和一只山羊。” 然而，这并不产生“我有一只狗、一只山羊和一只猫”，而是产生“我有一只猫、一只猫和一只猫”。在JavaScript中是否可以同时用多个其他字符串替换多个字符串，以便生成正确的结果 var str = "I have a cat, a dog, and a goat."; str = str.replace(/cat/gi, "dog"); str = str.replace(/dog/gi, "goat")

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

然而，这并不产生“我有一只狗、一只山羊和一只猫”，而是产生“我有一只猫、一只猫和一只猫”。在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".

特定溶液您可以使用一个函数替换每个函数

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

概括起来如果您想动态地维护regex，并且只需将未来的交换添加到映射中，您可以这样做

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

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

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

要添加或更改任何其他替换，您只需编辑地图即可

使其可重复使用如果你想让它成为一个通用模式，你可以把它拉出来，变成这样一个函数

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

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

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

因此，您只需将str和替换的映射传递给函数，它就会返回转换后的字符串

为了确保Object.keys在较旧的浏览器中工作，请添加一个polyfill，例如从或。

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

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'

String.prototype.replaceSome=function（）{
var replaceWith=Array.prototype.pop.apply（参数），
i=0，
r=这个，
l=参数长度；
对于（；i我在@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)

返回“废话234433废话”
这样，它将匹配mapObj中的键，而不是匹配的单词“
这对我很有用：
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"


蓝先生
他有一座蓝色的房子和一辆蓝色的汽车
试试看
函数myFunction（）{
var str=document.getElementById（“demo”）.innerHTML；
var res=str.replace（/\n | | car/gi，函数myFunction（x）{
如果（x='\n'）{return x='
'；}
如果（x=''）{return x='；}
如果（x=='car'）{return x='BMW'}
否则{return x；}//必须
});
document.getElementById（“demo”）.innerHTML=res；
}
以防有人想知道为什么原始海报的解决方案不起作用：
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."

我编写了这个npm包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" 

使用常规函数定义要替换的模式，然后使用替换函数处理输入字符串
var i = new RegExp('"{','g'),
    j = new RegExp('}"','g'),
    k = data.replace(i,'{').replace(j,'}');

解决方案（首先包括此文件）：将多个字符串替换为多个其他字符串：
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));
    });
});

使用我的软件包，您可以执行以下操作：
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.'

使用编号的项目以防止再次更换。
乙二醇
然后
工作原理：-
%\d+查找a%后面的数字。括号表示数字
该数字（作为字符串）是lambda函数的第二个参数n
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.

+n-1将字符串转换为数字，然后减去1以索引pets数组
然后将%数字替换为数组索引处的字符串
/g导致使用每个数字重复调用lambda函数，然后用数组中的字符串替换这些数字
在现代JavaScript中：-
replace_n=(str,...ns)=>str.replace(/%(\d+)/g,(_,n)=>ns[n-1])

使用：
范例
///1.使用reduce和objects替换
//arrayOfObjects.reduce（（f，s）=>`${f}`.replace（Object.keys[0]，s[Object.keys[0]），句子）
//如果在句子中找到，则用其值替换对象中的键
//如果找不到单词，则不会中断
//范例
常量数组对象=[
{植物：'人'}，
{smart:'dumb'}，
{和平：战争}
]
const语句1=‘植物是聪明的’
const result1=arrayOfObjects.reduce（（f，s）=>`${f}`.replace（Object.keys[0]，s[Object.keys[0]]），句子1）
console.log（result1）
//结果1：
//男人是哑巴
//额外：字符串插入python样式，带有单词和索引数组
//用法
//arrayOfWords.reduce（（f，s，i）=>`${f}`。替换（`{i}}}，s），句子）
//其中arrayOfWords包含要插入句子中的单词
//范例
//替换句子中arrayOfWords中定义的尽可能多的单词
//使用python类型{0}、{1}等表示法
//五个代替
常量语句2='{0}是{1}，{2}是{3}每隔{5}'
//但阵列中有四个？不会断开
const words2=['man'、'dumb'、'plants'、'smart']
//会发生什么？
const result2=words2.reduce（（f，s，i）=>`${f}`。replace（`{${i}}`，s），句子2）
console.log（result2）
//结果2：
//人是哑的，植物是聪明的
//替换数组中定义的尽可能多的单词
//三个代替
常量语句3='{0}是{1}和{2}'
//但是有五个在阵列中
const words3=['man'、'dumb'、'plant'、'smart']
//发生了什么事？没有破裂
const result3=words3.reduce（（f，s，i）=>`${f}`。replace（`{${i}}`，s），句子3）
console.log（result3）
//结果3：
//人是哑的，植物
你可以用分隔符找到并替换字符串

var obj={
“名字”：“约翰”，
“lastname”：“Doe”
}
var text=“我的名字是{firstname}，我的名字是{lastname}”
警报（mutliStringReplace（obj，文本））
函数mutliStringReplace（对象，字符串）{
var=字符串
var entries=Object.entries（Object）；
条目。forEach（（第段）=>{
变量find='{'+para[0]+'}'
var regExp=new regExp（find，'g'）
val=val.replace（regExp，第[1]段）
})
返回val；
}
您可以用于此目的。它基本上是一个字符串.replace（regexp，…）
对应项，它允许在一次过程中进行多个替换，同时保留字符串.replace（…）
的全部功能
披露：我是
str.replace(/%(\d+)/g, (_, n) => pets[+n-1])

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

    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."

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)

/\b(cathy|cat|catch)\b/gi

\b(?:cathy|cat|catch)\b

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

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.