343

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

var string = '#Please send_an_information_pack_to_the_following_address:';

我试过这个：

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

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

4

18 回答 18

633

使用 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';

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

于 2013-05-16T00:11:49.473 回答
92

如果你想替换多个字符，你可以调用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

于 2017-06-10T16:06:07.657 回答
57

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

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

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

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

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

var replaceChars={ "#":"" , "_":" " };
string.replace(/#|_/g,function(match) {return replaceChars[match];})
于 2013-05-16T00:21:17.850 回答
48

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

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

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

于 2013-05-16T00:10:17.277 回答
7

你可以试试这个：

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

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

于 2016-09-09T14:36:36.140 回答
7

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

所以我用

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

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

于 2018-07-12T10:50:56.013 回答
6

第二次更新

我开发了以下功能以在生产中使用，也许它可以帮助其他人。它基本上是原生的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"
于 2019-01-24T03:32:32.927 回答
5

请试试：

  • 替换多字符串

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

祝你好运！

于 2017-11-16T09:45:18.420 回答
4

你也可以试试这个：

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')
于 2016-03-29T05:38:15.137 回答
4

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

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

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

于 2021-04-01T11:12:47.443 回答
3

这是一个没有 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;
}
于 2015-05-05T13:31:55.427 回答
2

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

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

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

Javascript 正则表达式

于 2013-05-16T00:16:54.913 回答
2

yourstring = '#请发送_an_information_pack_to_the_following_address:';

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

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

newstring2 是你的结果

于 2017-11-12T07:43:02.337 回答
2

对于什么都没有替换，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]);
于 2020-11-13T10:51:02.880 回答
1

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

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


var string_norm = string.replace(/[ְֱֲֳִֵֶַָֹֹּׁׂ]/g, '');
document.getElementById("demo").innerHTML = (string_norm);
于 2021-11-03T20:50:09.973 回答
0 

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}'))

于 2020-07-02T09:04:38.023 回答
0

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

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

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

于 2021-11-24T05:36:17.930 回答
-1

这是一个使用“减少”多次替换函数的“安全 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);
    }
于 2019-09-07T15:00:29.943 回答