Zamień wiele znaków w jednym wywołaniu zamiany

Bardzo proste małe pytanie, ale nie do końca rozumiem, jak to zrobić.

Muszę zastąpić każde wystąpienie „_” spacją, a każde wystąpienie „#” niczym / pustym.

var string = '#Please send_an_information_pack_to_the_following_address:';

Próbowałem tego:

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

Nie bardzo lubię takie łańcuchowe polecenia. Czy istnieje inny sposób na zrobienie tego w jednym?

Użyj operatora OR ( |):

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

Możesz także użyć klasy postaci:

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

Skrzypce

Jeśli chcesz zastąpić skrót jedną rzeczą, a podkreślnik inną, musisz po prostu połączyć łańcuch. Możesz jednak dodać prototyp:

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

Ale dlaczego nie łańcuch? Nie widzę w tym nic złego.

Łańcuchy są fajne, po co je odrzucać?

W każdym razie tutaj jest inna opcja w jednym zamienniku:

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

Zastąpienie wybierze „” if match == "#", "" jeśli nie.

[Aktualizacja] Aby uzyskać bardziej ogólne rozwiązanie, możesz przechowywać zastępcze ciągi w obiekcie:

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

Jeśli chcesz zastąpić wiele znaków, możesz wywołać String.prototype.replace()argument z argumentem zastępującym będącym funkcją wywoływaną dla każdego dopasowania. Wszystko czego potrzebujesz to obiekt reprezentujący odwzorowanie znaków, którego użyjesz w tej funkcji.

Na przykład, jeśli chcesz azastąpić x, bze yi cze zmożna zrobić coś takiego:

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

Wyjście :234xyz567yyyyxz

Określ /g(globalną) flagę w wyrażeniu regularnym, aby zastąpić wszystkie dopasowania zamiast tylko pierwszego:

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

Aby zastąpić jedną postać jedną rzeczą, a inną postacią inną, tak naprawdę nie można się obejść, potrzebując dwóch osobnych wezwań replace. Możesz ją abstrakcyjnie przekształcić w funkcję, podobnie jak Doorknob, chociaż prawdopodobnie chciałbym, aby wziął obiekt ze starymi / nowymi parami klucz / wartość zamiast płaskiej tablicy.

Możesz także spróbować tego:

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

findodnosi się do tekstu, który można znaleźć, i replacedo tekstu, który ma zostać zastąpiony

Zastąpi to znaki bez rozróżniania wielkości liter. Aby zrobić inaczej, wystarczy zmienić flagi Regex zgodnie z wymaganiami. Np .: w przypadku rozróżniania wielkości liter należy wymienić:

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

Możesz po prostu spróbować:

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

to zastąpi., - i # twoim zamiennikiem!

Oto prosty sposób na zrobienie tego bez RegEx.
Możesz prototypować i / lub buforować rzeczy według potrzeb.

// 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;
}

Proszę spróbować:

• zastąp ciąg wielu

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

• wymienić wiele znaków

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

Powodzenia!

Możesz również przekazać obiekt RegExp do metody zamiany, takiej jak

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

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

JavaScript RegExp

yourstring = '# Please send_an_information_pack_to_the_following_address:';

zamień „#” na „” i zastąp „_” spacją

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

newstring2 to twój wynik

Oto kolejna wersja wykorzystująca String Prototype. Cieszyć się!

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"

Nie wiem, czy ile to pomoże, ale chciałem usunąć <b>i </b>od mojego ciąg

więc użyłem

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

więc w zasadzie, jeśli chcesz ograniczyć ograniczoną liczbę postaci i nie marnować czasu, przyda się to.

Oto funkcja „bezpiecznego HTML” przy użyciu funkcji wielokrotnego zastępowania „zmniejsz” (ta funkcja stosuje każdą zamianę do całego łańcucha, więc zależności między zamiennikami są znaczące).

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