javascript - 在一次替换调用中替换多个字符

Question

我需要将“_”的每个实例替换为空格，将“#”的每个实例替换为空/空。

var string = '#Please send_an_information_pack_to_the_following_address:';

我试过这个：

string.replace('#','').replace('_', ' ');

我真的不喜欢这样的链接命令。有没有另一种方法可以做到这一点？

Answer 1

使用 OR 运算符 ( |)：

var str = '#this #is__ __#a test###__';
str.replace(/#|_/g,''); // result: "this is a test"

您还可以使用字符类：

str.replace(/[#_]/g,'');

小提琴

如果你想用一个东西替换散列，用另一个东西替换下划线，那么你只需要链接。但是，您可以添加一个原型：

String.prototype.allReplace = function(obj) {
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'g'), obj[x]);
    }
    return retStr;
};

console.log('aabbaabbcc'.allReplace({'a': 'h', 'b': 'o'}));
// console.log 'hhoohhoocc';

为什么不链呢？我认为这没有错。

Answer 2

如果你想替换多个字符，你可以调用String.prototype.replace()替换参数是为每个匹配调用的函数。您只需要一个表示您将在该函数中使用的字符映射的对象。

例如，如果你想a用x、b和替换y，你可以这样做：cz

var chars = {'a':'x','b':'y','c':'z'};
var s = '234abc567bbbbac';
s = s.replace(/[abc]/g, m => chars[m]);
console.log(s);

输出：234xyz567yyyyxz

Answer 3

链接很酷，为什么不理会它？

无论如何，这是一次替换的另一种选择：

string.replace(/#|_/g,function(match) {return (match=="#")?"":" ";})

如果 match=="#"，则替换将选择 ""，否则将选择 ""。

[更新]对于更通用的解决方案，您可以将替换字符串存储在一个对象中：

var replaceChars={ "#":"" , "_":" " };
string.replace(/#|_/g,function(match) {return replaceChars[match];})

Answer 4

/g在正则表达式上指定（全局）标志以替换所有匹配项，而不仅仅是第一个：

string.replace(/_/g, ' ').replace(/#/g, '')

要用一种东西替换一个字符，用另一种东西替换一个不同的字符，你无法真正绕过需要两次单独调用replace. 您可以像 Doorknob 那样将它抽象为一个函数，尽管我可能会让它采用一个具有旧/新作为键/值对的对象，而不是一个平面数组。

Answer 5

你可以试试这个：

str.replace(/[.#]/g, 'replacechar');

这将用您的 replacechar 替换 .,- 和 # ！

Answer 6

我不知道这是否有多大帮助，但我想从我的字符串<b>中删除</b>

所以我用

mystring.replace('<b>',' ').replace('</b>','');

因此，基本上，如果您希望减少有限数量的字符并且不浪费时间，这将很有用。

Answer 7

第二次更新

我开发了以下功能以在生产中使用，也许它可以帮助其他人。它基本上是原生的replaceAll Javascript 函数的循环，它不使用正则表达式：

function replaceMultiple(text, characters){
  for (const [i, each] of characters.entries()) {
    const previousChar = Object.keys(each);
    const newChar = Object.values(each);

    text = text.replaceAll(previousChar, newChar);
  }  
  
return text
}

用法很简单。以下是使用 OP 示例的样子：

const text = '#Please send_an_information_pack_to_the_following_address:';
const characters = [
    {
    "#":""
    },
   {
    "_":" "
    },
]

const result = replaceMultiple(text, characters);

console.log(result); //'Please send an information pack to the following address:'

更新

您现在可以本机使用replaceAll。

过时的答案

这是另一个使用字符串原型的版本。享受！

String.prototype.replaceAll = function(obj) {
    let finalString = '';
    let word = this;
    for (let each of word){
        for (const o in obj){
            const value = obj[o];
            if (each == o){
                each = value;
            }
        }
        finalString += each;
    }
    
    return finalString;
};

'abc'.replaceAll({'a':'x', 'b':'y'}); //"xyc"

Answer 8

请试试：

• 替换多字符串

  var str = "http://www.abc.xyz.com"; str = str.replace(/http:|www|.com/g, ''); //str is "//.abc.xyz"

• 替换多字符

  var str = "a.b.c.d,e,f,g,h"; str = str.replace(/[.,]/g, ''); //str is "abcdefgh";

祝你好运！

Answer 9

你也可以试试这个：

function replaceStr(str, find, replace) {
    for (var i = 0; i < find.length; i++) {
        str = str.replace(new RegExp(find[i], 'gi'), replace[i]);
    }
    return str;
}

var text = "#here_is_the_one#";
var find = ["#","_"];
var replace = ['',' '];
text = replaceStr(text, find, replace);
console.log(text);

find指要找到replace的文本和要替换的文本

这将替换不区分大小写的字符。要做其他方式只需根据需要更改正则表达式标志。例如：对于区分大小写的替换：

new RegExp(find[i], 'g')

Answer 10

多个子字符串可以用一个简单的正则表达式替换。例如，我们要将数字(123) 456-7890变成1234567890，我们可以这样做。

var a = '(123) 456-7890';
var b = a.replace(/[() -]/g, '');
console.log(b); // results 1234567890

我们可以在 [] 之间传递要替换的子字符串，而要使用的字符串应该作为第二个参数传递给 replace 函数。

Answer 11

这是一个没有 RegEx 的简单方法。
您可以根据需要制作原型和/或缓存内容。

// Example: translate( 'faded', 'abcdef', '123456' ) returns '61454'
function translate( s, sFrom, sTo ){
    for ( var out = '', i = 0; i < s.length; i++ ){
        out += sTo.charAt( sFrom.indexOf( s.charAt(i) ));
    }
    return out;
}

Answer 12

您还可以将 RegExp 对象传递给 replace 方法，例如

var regexUnderscore = new RegExp("_", "g"); //indicates global match
var regexHash = new RegExp("#", "g");

string.replace(regexHash, "").replace(regexUnderscore, " ");

Javascript 正则表达式

Answer 13

yourstring = '#请发送_an_information_pack_to_the_following_address:';

将 '#' 替换为 '' 并将 '_' 替换为空格

var newstring1 = yourstring.split('#').join('');
var newstring2 = newstring1.split('_').join(' ');

newstring2 是你的结果

Answer 14

对于什么都没有替换，tckmn 的答案是最好的。

如果您需要用与匹配项对应的特定字符串替换，这里是 Voicu 和 Christophe 的答案的变体，可以避免重复匹配的内容，这样您就不必记住在两个地方添加新匹配项：

const replacements = {
  '’': "'",
  '“': '"',
  '”': '"',
  '—': '---',
  '–': '--',
};
const replacement_regex = new RegExp(Object
  .keys(replacements)
  // escape any regex literals found in the replacement keys:
  .map(e => e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
  .join('|')
, 'g');
return text.replace(replacement_regex, e => replacements[e]);

Answer 15

这适用于意第绪语其他角色，例如 NEKUDES

var string = "נׂקֹוַדֹּוֶת";


var string_norm = string.replace(/[ְֱֲֳִֵֶַָֹֹּׁׂ]/g, '');
document.getElementById("demo").innerHTML = (string_norm);

Answer 16

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

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

Answer 17

不知道为什么还没有人提供这个解决方案，但我发现它工作得很好：

var string = '#Please send_an_information_pack_to_the_following_address:'
var placeholders = [
    "_": " ",
    "#": ""
]

for(var placeholder in placeholders){
    while(string.indexOf(placeholder) > -1) {
        string = string.replace(placeholder, placeholders[placeholder])
    }
}

您可以根据需要添加任何占位符，而无需更新您的函数。简单的！

Answer 18

这是一个使用“减少”多次替换函数的“安全 HTML”函数（此函数将每个替换应用于整个字符串，因此替换之间的依赖性很重要）。

// Test:
document.write(SafeHTML('<div>\n\
    x</div>'));

function SafeHTML(str)
    {
    const replacements = [
        {'&':'&amp;'},
        {'<':'&lt;'},
        {'>':'&gt;'},
        {'"':'&quot;'},
        {"'":'&apos;'},
        {'`':'&grave;'},
        {'\n':'<br>'},
        {' ':'&nbsp;'}
        ];
    return replaceManyStr(replacements,str);
    } // HTMLToSafeHTML

function replaceManyStr(replacements,str)
    {
    return replacements.reduce((accum,t) => accum.replace(new RegExp(Object.keys(t)[0],'g'),t[Object.keys(t)[0]]),str);
    }