Jak zastąpić wszystkie wystąpienia ciągu znaków w JavaScript?

str = str.replace(/abc/g, '');

W odpowiedzi na komentarz:

var find = 'abc';
var re = new RegExp(find, 'g');

str = str.replace(re, '');

W odpowiedzi na kliknij w komentarz , możesz go jeszcze bardziej uprościć:

function replaceAll(str, find, replace) {
    return str.replace(new RegExp(find, 'g'), replace);
}

Uwaga: wyrażenia regularne zawierają znaki specjalne (meta) i jako takie niebezpieczne jest ślepe przekazywanie argumentu w powyższej funkcji find bez wstępnego przetwarzania go w celu uniknięcia tych znaków. Jest to omówione w Mozilla Developer Network 'S JavaScript Guide on Regular Expressions, gdzie przedstaw następującą funkcję użytkową:

function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

Tak więc aby powyższa funkcja replaceAll() była bezpieczniejsza, można ją zmodyfikować do następującej wartości, jeśli dołączysz również escapeRegExp:

function replaceAll(str, find, replace) {
    return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}

Uwaga: nie używaj tego w prawdziwym kodzie.

Jako alternatywa dla wyrażeń regularnych dla prostego ciągu literalnego, możesz użyć

str = "Test abc test test abc test...".split("abc").join("");

Ogólny wzór to

str.split(search).join(replacement)

W niektórych przypadkach było to szybsze niż użycie replaceAll i wyrażenia regularnego, ale wydaje się, że nie ma to już miejsca w nowoczesnych przeglądarkach. Tak więc, to powinno być używane tylko jako szybki hack, aby uniknąć konieczności ucieczki wyrażenia regularnego, a nie w prawdziwym kodzie.

Użycie wyrażenia regularnego z zestawem znaczników g zastąpi wszystkie:

someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains "the dog looks like a dog"

Zobacz też

Oto prototypowa funkcja string oparta na zaakceptowanej odpowiedzi:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find, 'g'), replace);
};

EDIT

Jeśli Twoje find będzie zawierało znaki specjalne, musisz przed nimi uciec:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};

Http://jsfiddle.net/cdbzL/

aktualizacja:

Jest trochę późno na aktualizację, ale ponieważ właśnie natknąłem się na to pytanie i zauważyłem, że moja poprzednia odpowiedź nie jest taka, z której jestem zadowolony. Ponieważ pytanie dotyczyło zastąpienia jednego słowa, To niesamowite, że nikt nie pomyślał o użyciu granic słów(\b)

'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"

Jest to prosty regex, który unika zastępowania części słów w większości przypadków. Jednak myślnik - jest nadal uważany za granicę słowa. Tak więc warunki mogą być stosowane w ten przypadek, aby uniknąć zastąpienia ciągów takich jak cool-cat:

'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"

Zasadniczo to pytanie jest takie samo jak pytanie tutaj: JavaScript zamień "'" na "" "

@Mike, sprawdź odpowiedź, którą tam dałem... regexp nie jest jedynym sposobem na zastąpienie wielu wystąpień subsrtingu, z dala od niego. Myśl elastyczna, myśl rozdzielona!

var newText = "the cat looks like a cat".split('cat').join('dog');

Alternatywnie, aby zapobiec wymianie części wyrazów-co zrobi również zatwierdzona odpowiedź! Możesz obejść ten problem za pomocą wyrażenia regularne, które są, przyznaję, nieco bardziej złożone i jako wynik tego, nieco wolniejsze, też: {]}

var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");

Wyjście jest takie samo jak zaakceptowana odpowiedź, jednak przy użyciu wyrażenia /cat/g na tym łańcuchu:

var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ?? 

UPS rzeczywiście, to prawdopodobnie nie jest to, czego chcesz. Więc co? IMHO, regex który tylko warunkowo zastępuje "kota". (tzn. nie jest częścią słowa), jak tak:

var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return "the dog looks like a dog, not a caterpillar or coolcat"

Http://www.javascriptkit.com/jsref/regexp.shtml

Http://www.regular-expressions.info

Ostatni dodatek:

Biorąc pod uwagę, że to pytanie wciąż ma wiele wyświetleń, pomyślałem, że mogę dodać przykład .replace używany z funkcją callback. W tym przypadku znacznie upraszcza wyrażenie i zapewnia jeszcze większą elastyczność, jak zastąpienie prawidłową kapitalizacją lub zastąpienie obu cat i cats za jednym zamachem:

'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
   .replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
    {
       //check 1st, capitalize if required
       var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
       if (char1 === ' ' && char2 === 's')
       {//replace plurals, too
           cat = replacement + 's';
       }
       else
       {//do not replace if dashes are matched
           cat = char1 === '-' || char2 === '-' ? cat : replacement;
       }
       return char1 + cat + char2;//return replacement string
    });
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar

Dopasowanie do globalnego wyrażenia regularnego:

anotherString = someString.replace(/cat/g, 'dog');

str = str.replace(/abc/g, '');

Lub spróbuj funkcji replaceAll stąd:

Jakie są użyteczne metody JavaScript rozszerzające obiekty wbudowane?

str = str.replaceAll('abc', ''); OR

var search = 'abc';
str = str.replaceAll(search, '');

EDIT: Wyjaśnienie o dostępności zamienników

Metoda 'replaceAll' jest dodawana do prototypu String. Oznacza to, że będzie on dostępny dla wszystkich obiektów string/literałów.

Np.

var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'

Powiedz, że chcesz zastąpić wszystkie " abc "przez " x":

let some_str = 'abc def def lom abc abc def'.split('abc').join('x')
console.log(some_str) //x def def lom x x def

Próbowałem pomyśleć o czymś prostszym niż zmodyfikowanie prototypu string.

Użyj wyrażenia regularnego:

str.replace(/abc/g, '');

Zastępowanie pojedynczych cudzysłowów:

function JavaScriptEncode(text){
    text = text.replace(/'/g,''')
    // More encode here if required

    return text;
}

//loop it until number apparences comes to 0. Lub po prostu skopiuj / wklej

    function replaceAll(find, replace, str) 
    {
      while( str.indexOf(find) > -1)
      {
        str = str.replace(find, replace);
      }
      return str;
    }

To jest najszybsza wersja , która nie używa wyrażeń regularnych .

Poprawione jsperf

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

Jest prawie dwa razy tak szybki jak metoda split and join.

Jak wspomniano w komentarzu tutaj, to nie będzie działać, jeśli Twoja omit zmienna zawiera place, jak w: replaceAll("string", "s", "ss"), ponieważ zawsze będzie w stanie zastąpić inne wystąpienie tego słowa.

Jest jeszcze jeden jsperf z wariantami na moim rekurencyjnym zastępowaniu, które idą nawet faster ( http://jsperf.com/replace-all-vs-split-join/12)!

• aktualizacja 27 lipca 2017: wygląda na to, że RegExp ma teraz najszybszą wydajność w niedawno wydanej Chrome 59.

str = str.replace(new RegExp("abc", 'g'), "");

Zadziałało dla mnie lepiej niż powyższe odpowiedzi. tak więc new RegExp("abc", 'g') tworzy Wyrażenie regularne, które pasuje do wszystkich znaczników occurence ('g') w tekście ("abc"). Druga część to to, co zostaje zastąpione, w Twoim przypadku empty string (""). {[5] } jest łańcuchem znaków i musimy go nadpisać, ponieważ replace(...) po prostu zwraca wynik, ale nie nadpisuje. W niektórych przypadkach możesz chcieć tego użyć.

function replaceAll(str, find, replace) {
  var i = str.indexOf(find);
  if (i > -1){
    str = str.replace(find, replace); 
    i = i + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + replaceAll(st2, find, replace);
    }       
  }
  return str;
}

Jeśli to, co chcesz znaleźć jest już w łańcuchu, a nie masz pod ręką escapera regex, możesz użyć join / split:

    function replaceMulti(haystack, needle, replacement)
    {
        return haystack.split(needle).join(replacement);
    }

    someString = 'the cat looks like a cat';
    console.log(replaceMulti(someString, 'cat', 'dog'));

var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

Http://jsfiddle.net/ANHR9/

while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}

Użycie RegExp W JavaScript może wykonać zadanie za ciebie, po prostu zrób coś takiego jak poniżej:

var str ="Test abc test test abc test test test abc test test abc";
str = str.replace(/abc/g, '');

Jeśli myślisz o ponownym użyciu, Utwórz funkcję, aby to zrobić za ciebie, ale nie jest to zalecane, ponieważ jest to tylko jedna funkcja liniowa, ale ponownie, jeśli mocno się z tego skorzystasz, możesz napisać coś takiego:

String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
  return this.replace(new RegExp(string, 'g'), replaced);
};

I po prostu używaj go w kodzie w kółko jak poniżej:

var str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');

Ale jak wspomniałem wcześniej, nie zrobi to wielkiej różnicy pod względem linii, aby być pisanie lub wydajność, tylko buforowanie funkcji może wpłynąć na szybszą wydajność długich łańcuchów, a także dobrą praktykę suchego kodu, jeśli chcesz ponownie użyć.

Podoba mi się ta metoda (wygląda trochę czyściej):

text = text.replace(new RegExp("cat","g"), "dog"); 

Jeśli łańcuch zawiera podobny wzór jak abccc, możesz użyć tego:

str.replace(/abc(\s|$)/g, "")

Jeśli próbujesz upewnić się, że szukany ciąg znaków nie istnieje nawet po zastąpieniu, musisz użyć pętli.

Na przykład:

var str = 'test aabcbc';
str = str.replace(/abc/g, '');

Kiedy ukończysz, nadal będziesz miał "testowe abc"!

Najprostsza pętla do rozwiązania to:

var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
   str.replace(/abc/g, '');
}

var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!

To może być szczególnie przydatne przy szukaniu duplikatów łańcuchów.
Na przykład, jeśli mamy 'a,,, b' i chcemy usunąć wszystkie zduplikowane przecinki.
[W takim razie można to zrobić .replace ( / , + / g,','), ale w pewnym momencie regex staje się złożony i wystarczająco powolny, aby zamiast tego zapętlić.]

var string  = 'Test abc Test abc Test abc Test abc'
string = string.replace(/abc/g, '')
console.log(string)

Możesz spróbować połączyć te dwie potężne metody.

"test abc test test abc".split("abc").join("")

Możesz po prostu użyć poniższej metody

/**
 * Replace all the occerencess of $find by $replace in $originalString
 * @param  {originalString} input - Raw string.
 * @param  {find} input - Target key word or regex that need to be replaced.
 * @param  {replace} input - Replacement key word
 * @return {String}       Output string
 */
function replaceAll(originalString, find, replace) {
  return originalString.replace(new RegExp(find, 'g'), replace);
};

Chociaż ludzie wspominali o użyciu regex, ale jest lepsze podejście, jeśli chcesz zastąpić tekst niezależnie od przypadku tekstu. Jak wielkie lub małe litery. Użyj poniższej składni

//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');

//Output will be all the occurrences removed irrespective of casing.

Możesz odnieść się do szczegółowego przykładu tutaj .

Po prostu wykonaj ten regex oneliner dodając wielkość liter, więc jeśli zrobisz "ABC", to będzie działać tak samo jak dla "abc".

str = str.replace(/abc/gi, "");

Po prostu dodaj /g

document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

Do

// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');

/g oznacza globalny

Działa dla mnie następująca Funkcja:

String.prototype.replaceAllOccurence = function(str1, str2, ignore) 
{
    return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;

Teraz wywołaj funkcje w następujący sposób:

"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");

Po prostu skopiuj i wklej ten kod w konsoli przeglądarki, aby przetestować.

Używam p do przechowywania wyniku z poprzedniej rekurencji:

function replaceAll(s, m, r, p) {
    return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}

Zastąpi wszystkie wystąpienia w łańcuchu s aż będzie to możliwe:

replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'

Aby uniknąć nieskończonej pętli sprawdzam czy zamiennik r zawiera dopasowanie m :

replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'