55 Pytanie: Jak zastąpić wszystkie wystąpienia ciągu w JavaScript

pytanie utworzone w Sun, Nov 18, 2018 12:00 AM

Mam ten ciąg:

 
"Test abc test test abc test test test abc test test abc"

Robi

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

wydaje się usuwać tylko pierwsze wystąpienie abc w powyższym ciągu. Jak mogę zastąpić wszystkie jego wystąpienia?

    
3821
  1. 2009-07-17 17: 55: 11Z
  2. SIMPLEST: var str = 'abcabcbabc'; str.replace(/a/g, 'x'); --> 'xbcxbcxbc
    2016-07-06 18: 33: 00Z
  3. Uważaj, że opcja Federico jest świetna, o ile twój ciąg znaków do zastąpienia nie zawiera specjalnych znaków regularnych.
    2017-04-26 07: 43: 20Z
  4. @ Andrew Specjalne znaki wyrażeń mogą być unikalne dla zwykłych znaków.
    2017-10-26 10: 34: 15Z
  5. Dla każdego, kto się zastanawia, możesz uciec z wyrażenia regularnego przez ukośnik odwrotny. Na przykład str.replace (/\_ /g) powinien działać, ale nie str.replace (/] /g), ponieważ ']' jest specjalnym znakiem regex.
    2018-01-11 12: 41: 03Z
30 odpowiedzi                              30                         

Ze względu na kompletność zastanawiałem się, jaką metodę powinienem użyć, aby to zrobić. Istnieją zasadniczo dwa sposoby, aby to zrobić, jak sugerują inne odpowiedzi na tej stronie.

Uwaga: generalnie nie zaleca się rozszerzania wbudowanych prototypów w JavaScript. Dostarczam jako rozszerzenia do prototypu String po prostu dla celów ilustracyjnych, pokazując różne implementacje hipotetycznej standardowej metody na wbudowanym prototypie String.


Implementacja na podstawie regularnego wyrażenia

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

Implementacja podzielona i dołączona (funkcjonalna)

 
String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.split(search).join(replacement);
};

Nie wiedząc zbyt wiele o tym, jak wyrażenia regularne działają za kulisami pod względem wydajności, skłaniałem się ku podziałowi i łączeniu implementacji w przeszłości bez myślenia o wydajności. Kiedy zastanawiałem się, co jest bardziej wydajne i jakim marginesem, użyłem go jako wymówki, by się dowiedzieć.

Na moim komputerze z Chrome Windows 8 implementacja oparta na wyrażeniach regularnych jest najszybsza , a implementacja podzielona i dołączona jest o 53% wolniejsza . Oznacza to, że wyrażenia regularne są dwa razy szybsze od użytego wejścia lorem ipsum.

Sprawdź ten test porównawczy , uruchamiając te dwie implementacje względem siebie.


Jak zauważono w poniższym komentarzu autorstwa @ThomasLeduc i innych, może wystąpić problem z implementacją opartą na wyrażeniach regularnych, jeśli search zawiera pewne znaki zarezerwowane jako znaki specjalne w wyrażeniach regularnych . Implementacja zakłada, że ​​wywołujący ucieknie z łańcucha wcześniej lub przekaże tylko łańcuchy bez znaków w tabeli w Wyrażenia regularne (MDN).

MDN zapewnia również implementację umożliwiającą ucieczkę z naszych łańcuchów. Byłoby miło, gdyby to było również standaryzowane jako RegExp.escape(str), ale niestety nie istnieje:

 
function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}

Możemy wywołać escapeRegExp w naszej implementacji String.prototype.replaceAll, jednak nie jestem pewien, jak bardzo wpłynie to na wydajność (potencjalnie nawet dla ciągów, dla których ucieczka nie jest potrzebna, jak wszystkie ciągi alfanumeryczne).

    
2203
2017-05-27 21: 55: 56Z
  1. W systemie Android 4.1 metoda regexp jest o 15% szybsza, ale nie uciekasz przed wyrażeniem, którego szukasz, więc ten test jest niekompletny.
    2015-01-19 00: 01: 14Z
  2. Istnieje problem z tym rozwiązaniem, jeśli szukany ciąg zawiera znaki specjalne wyrażenia regularnego, będą one interpretowane. Polecam odpowiedź @Sandy Unitedwolf.
    2016-02-17 16: 09: 35Z
  3. Pierwszy z nich to zrobi: 'bla.bla'.replaceAll ('. ',' _ '); „_______”. Drugi zrobi „bla_bla”, co jest bardziej ogólne, co chcesz zrobić.
    2016-02-21 01: 12: 56Z
  4. @ ThomasLeduc wygląda na to, że wspomniany problem można obejść z lodash = > lodash.com/docs/4.17.5#escapeRegExp
    2018-03-15 07: 47: 58Z
  5. To oczywiste absurdalne, że ludzie sami muszą implementować tę podstawową funkcjonalność. Dziękuję za wspaniałą odpowiedź.
    2018-08-22 12: 47: 36Z
 
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 komentarz Upvote , 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ą specjalne (meta) znaki i dlatego jest niebezpiecznie ślepo przekazać argument w powyższej funkcji find bez wstępnego przetworzenia go w celu uniknięcia tych znaków. Jest to opisane w Sieci programistów Mozilli Przewodnik JavaScript po wyrażeniach regularnych , gdzie prezentują następującą funkcję narzędzia:

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

Aby więc funkcja replaceAll() była bezpieczniejsza, można ją zmodyfikować na następujące, jeśli uwzględnisz również escapeRegExp:

 
function replaceAll(str, find, replace) {
    return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
    
3981
2017-06-21 22: 17: 14Z
  1. Wyrażenia regularne to jedyny sposób na wykonanie tego „z pudełka” bez implementacji własnej metody „replaceAll”. Nie sugeruję ich użycia tylko dla ich wykorzystania.
    2009-07-17 19: 47: 19Z
  2. To jest moja własna funkcja z tego komentarza: function replaceAll(find, replace,str) { var re = new RegExp(find, 'g'); str = str.replace(re, replace); return str; }
    2009-07-17 21: 11: 22Z
  3. Głównym zastrzeżeniem implementacji replaceAll jest to, że nie będzie działać, jeśli find zawiera metaznaki.
    2013-08-27 00: 39: 25Z
  4. @ SeanBright masz rację. Użyłem twojego javascript w kodzie php, więc musiałem dodać dodatkowy ukośnik, aby uciec. Na skrzydle twój kod jest idealny. Powinienem był sprawdzić. Przeprosiny jsfiddle.net/7y19xyq8
    2015-07-02 16: 38: 10Z
  5. 2017-09-12 15: 40: 12Z

Uwaga: nie używaj tego w prawdziwym kodzie.

Jako alternatywę 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żenie regularne, ale wydaje się, że tak nie jest w nowoczesnych przeglądarkach. Tak więc powinno to być naprawdę tylko szybkie hakowanie, aby uniknąć konieczności ucieczki z wyrażenia regularnego, a nie w prawdziwym kodzie.

    
1267
2017-01-24 14: 38: 59Z
  1. Zaskoczyło mnie to, ponieważ spodziewałbym się, że ta metoda będzie przydzielać więcej obiektów, tworząc więcej śmieci, a tym samym dłużej, ale kiedy faktycznie testowałem w przeglądarce tę metodę był o około 20% szybszy niż zaakceptowana odpowiedź. Wyniki mogą się oczywiście różnić.
    2013-09-20 20: 22: 39Z
  2. Byłem ciekawy siebie i ustawiłem to: jsperf.com/replace-all-vs-split-join . Wydaje się, że v8 jest po prostu szalony w dzieleniu /łączeniu tablic w porównaniu z innymi silnikami javascript.
    2013-11-23 21: 02: 01Z
  3. Bardzo ładny - również oszczędza ci możliwości złych RegExps podczas przekazywania znaków specjalnych. Dodaję ogólną flagę dla „znajdź to i zamień” we właściwości obiektu, ale obawiałem się, czy muszę zastąpić „.” lub „}” i zapomniałem, że korzystam z RegEx 3 miesiące później!
    2014-04-03 08: 01: 15Z
  4. W moim ipad2 /safari, split /join jest o 65% wolniejszy niż zastąpienie, więc Twoje wyniki mogą się różnić.
    2014-05-30 03: 30: 09Z
  5. I jako String.prototype: String.prototype.replaceAll = function(f,r){return this.split(f).join(r);}. Sposób użycia: "My string".replaceAll('st', ''); tworzy „Mój pierścień”
    2014-09-26 11: 50: 30Z

Użycie wyrażenia regularnego z ustawioną flagą 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 także tutaj

    
583
2016-05-17 12: 15: 25Z
  1. Myślę, że głupie, ale globalne wyrażenie JS jest jedynym sposobem na wielokrotne zastąpienie.
    2009-05-07 02: 43: 39Z
  2. dobrze technicznie możesz przejść przez var sourceText policzyć liczbę instancji (numOfInstances) używając substring lub podzielić i policzyć długość (wśród innych strategii) thatWhichYouWantToReplace do for (var i = 0; i < numOfInstances; i++){ sourceText = sourceText.replace('thatWhichYouWantToReplace', '');} lub jeszcze łatwiej po prostu użyj pętli while (while sourceText.indexOf(thatWhichYouWantToReplace > -1){ sourceText = sourceText.replace(...)), ale nie widzę powodu, dla którego chciałbyś zrobić to w ten sposób, gdy użycie /g jest tak łatwe i prawdopodobnie bardziej wydajne.
    2016-03-20 22: 20: 02Z

Oto funkcja prototypu łańcucha oparta na zaakceptowanej odpowiedzi:

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

EDYCJA

Jeśli twój find będzie zawierał znaki specjalne, musisz uciec od nich:

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

Skrzypce: http://jsfiddle.net/cdbzL/

    
96
2013-10-07 16: 40: 16Z
  1. Ale co jeśli find zawiera znaki takie jak . lub $, które mają specjalne znaczenie w wyrażeniu regularnym?
    2013-10-07 11: 30: 27Z
  2. @ callum W takim przypadku musisz uciec ze swojej zmiennej find (patrz edycja powyżej).
    2013-10-07 16: 41: 14Z
  3. jesal, to wspaniałe rozwiązanie problemu z wymianą ciągów, z którym się spotkałem, i najwyraźniej przezwycięża "niezmienność" ciągów w JavaScript. Czy możesz wyjaśnić, w jaki sposób ta prototypowa funkcja zastępuje niezmienność łańcuchów? To działa ; Chcę tylko zrozumieć to dodatkowe pytanie, które on stawia.
    2016-01-12 00: 08: 38Z
  4. @ Tom: Nie w ogóle pokonuje niezmienność: var str = this tworzy drugie odwołanie do niezmiennego ciągu, do którego metoda replace jest stosowane, co z kolei zwraca nowy niezmienny ciąg . te funkcje prototypu zwracają nowy niezmienny ciąg, jeśli nie, można by napisać someStrVar.replaceAll('o', '0');, a someStrVar zostałoby zmienione. Zamiast tego musisz napisać someStrVar = someStrVar.replaceAll('o', '0'); < - zmień przypisanie, aby ustawić zmienną na nowy niezmienny ciąg . nie ma takiej możliwości. Spróbuj w konsoli: x = 'foobar'; x.replaceAll('o', '0'); x;
    2016-06-15 16: 26: 00Z

Aktualizacja :

Jest trochę za późno na aktualizację, ale odkąd 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 pojedynczego słowa, to niewiarygodne, ż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 proste wyrażenie regularne, które pozwala uniknąć zastępowania części słów w większości przypadków. Jednak myślnik - jest nadal uważany za granicę słów. W tym przypadku można użyć warunkowych, aby uniknąć zastępowania 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 podałem ... regexp nie jest jedynym sposobem na zastąpienie wielu wystąpień subskrypcji, daleko od tego. Myśl elastycznie, myśl podziel!

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

Alternatywnie, aby zapobiec zastępowaniu części wyrazów - co również zrobi zatwierdzona odpowiedź! Możesz obejść ten problem za pomocą wyrażeń regularnych, które, przyznaję, są nieco bardziej skomplikowane i jako rezultat tego, również nieco wolniejszy:

 
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 używając 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" ?? 

Rzeczywiście, to chyba nie jest to, czego chcesz. Co to jest? IMHO, wyrażenie regularne, które warunkowo zastępuje „kota”. (tj. nie jest częścią słowa), 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"

Domyślam się, że spełnia twoje potrzeby. Oczywiście nie jest to pełne zabezpieczenie, ale powinno wystarczyć, abyś zaczął. Polecam przeczytać więcej na tych stronach. To okaże się przydatne w doskonaleniu tego wyrażenia, aby spełnić Twoje specyficzne potrzeby.

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

http://www.regular-expressions.info


Ostateczne dodanie:

Biorąc pod uwagę, że to pytanie wciąż ma wiele widoków, pomyślałem, że mogę dodać przykład .replace używany z funkcją wywołania zwrotnego. W tym przypadku znacznie upraszcza wyrażenie i , zapewniając jeszcze większą elastyczność, np. Zastąpienie poprawnej wielkości liter lub zastąpienie 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
    
79
2017-05-23 11: 47: 36Z
  1. Myślę, że dodatkowa interesująca część powinna być umieszczona na dole. ps .: Zauważyłem, że połowa pierwszej linii jest poza obszarem, pozwól, że to naprawię!
    2013-07-04 16: 31: 06Z

Dopasuj do globalnego wyrażenia regularnego:

 
anotherString = someString.replace(/cat/g, 'dog');
    
59
2009-05-06 23: 23: 40Z
 
str = str.replace(/abc/g, '');

Lub wypróbuj tutaj funkcję replaceAll:

Jakie są przydatne metody JavaScript, które rozszerzają wbudowane w obiektach?

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

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

EDYCJA: wyjaśnienie dotyczące zastępowania całej dostępności

Metoda „replaceAll” została dodana do prototypu String. Oznacza to, że będzie dostępny dla wszystkich obiektów łańcuchowych /literałów.

np.

 
var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'
    
41
2017-05-23 12: 34: 57Z
  1. Czy możesz przepisać funkcję replaceAll () dla osób, które nie używają prototypu?
    2009-07-17 17: 57: 28Z
  2. @ Kliknij Upvote .... używasz prototypu, jest częścią wszystkich obiektów JS. Myślę, że myślisz o prototype.js bibliotece JS.
    2009-07-17 18: 20: 21Z
  3. seth, mała korekta. Jeśli dodasz metodę do prototypu, będzie ona dostępna dla wszystkich obiektów tego typu. Metoda replceAll została dodana do prototypu String i powinna działać dla wszystkich obiektów łańcuchowych.
    2009-07-17 18: 23: 53Z
  4. @ solutionyogi - Tak, wcześniej użyłem prototypu (poprawnie). Właśnie odnosiłem się do komentarza OP na temat „nieużywania prototypu”, który zakładałem, że oznacza Prototype.js (być może niepoprawnie?). Powinienem był powiedzieć „prototyp”, jak próbowałem powiedzieć, że obiekty JavaScript mają prototyp. W związku z tym PO już „wykorzystywał prototyp”, choć w „pośredni” sposób. Pośrednie może być niewłaściwym terminem używanym tutaj, ale jestem zmęczony, więc mea culpa.
    2009-07-17 23: 41: 22Z

Są to najbardziej popularne i czytelne metody.

 
var str = "Test abc test test abc test test test abc test test abc"

Method-01:

 
str = str.replace(/abc/g, "replaced text");

Method-02:

 
str = str.split("abc").join("replaced text");

Method-03:

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

Method-04:

 
while(str.includes("abc")){
    str = str.replace("abc", "replaced text");
}

Wyjście:

 
console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text
    
36
2019-04-01 12: 56: 49Z

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 myśleć o czymś prostszym niż modyfikowanie prototypu łańcucha.

    
35
2017-05-27 22: 01: 59Z
  1. Prosta, łatwa i prawdopodobnie najbardziej wydajna opcja: ładna odpowiedź.
    2016-10-25 23: 51: 29Z
  2. Nie wiem, czy działa wydajnie, ale .... to działa.
    2017-01-13 18: 18: 11Z
  3. Właściwie, choć nie dokonałem osobnego pomiaru, split /join jest zwykle bardzo skutecznym rozwiązaniem.
    2017-01-13 18: 30: 07Z
  4. jest nawet w chrome, 100% szybszy w Firefoksie i 50% wolniejszy w IE ...: jsperf.com/replace-regex-split-join
    2018-05-22 14: 39: 00Z

Użyj wyrażenia regularnego:

 
str.replace(/abc/g, '');
    
33
2017-05-27 21: 56: 32Z

Zastępowanie pojedynczych cudzysłowów:

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

    return text;
}
    
30
2017-12-17 15: 53: 28Z
  1. Jak mogę zmienić drugą linię, aby zastąpić ciągi? To nie działa: text = text.replace ('hey', 'hello'); Jakiś pomysł?
    2016-12-09 22: 37: 51Z
  2. Sure Stefan, oto kod ... text = text.replace (/hey /g, 'hello');
    2016-12-12 13: 56: 01Z

Użycie RegExp w JavaScript może wykonać zadanie za ciebie, po prostu zrób coś takiego jak poniżej, nie zapomnij o /g, po czym wyróżnij się na globalne :

 
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ę, która zrobi to za ciebie, ale nie jest to zalecane, ponieważ jest to tylko jedna funkcja liniowa, ale ponownie, jeśli używasz tego mocno, 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 swoim 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 już wspomniałem wcześniej, nie spowoduje to wielkiej różnicy w liniach, które mają być napisane lub wydajności, tylko buforowanie funkcji może mieć wpływ na szybsze działanie długich łańcuchów, a także dobrą praktykę kodu DRY, jeśli chcesz ponownie użyć.

    
28
2019-03-12 14: 48: 17Z

//zapętlaj, dopóki liczba wystąpień nie osiągnie 0. LUB po prostu skopiuj /wklej

 
    function replaceAll(find, replace, str) 
    {
      while( str.indexOf(find) > -1)
      {
        str = str.replace(find, replace);
      }
      return str;
    }
    
23
2013-09-05 14: 01: 12Z
  1. Ta metoda jest niebezpieczna, nie używaj jej. Jeśli ciąg zastępczy zawiera słowo kluczowe wyszukiwania, wystąpi nieskończona pętla. Przechowuj wynik .indexOf w zmiennej i używaj tej zmiennej jako drugiego parametru .indexOf (minus długość słowa kluczowego plus długość ciągu zastępującego).
    2013-10-29 11: 33: 41Z
  2. Zastanawiam się nad pierwszym zastąpieniem wzorca wyszukiwania wyeksploatowanym znakiem Unicode, którego jesteśmy pewni, że nie jest on używany w ciągu wejściowym. Jak U + E000 w strefie prywatnej. A następnie zastąp go z powrotem do celu. Zbudowałem to tutaj. . Nie jestem pewien, czy to dobry pomysł.
    2014-07-02 13: 42: 42Z

To jest najszybsza wersja , w której nie używa się wyrażeń regularnych .

Zmieniony 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 szybszy niż metoda dzielenia i łączenia.

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

Jest jeszcze jeden jsperf z wariantami na mojej rekursywnej zamianie, który idzie jeszcze szybciej ( 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 wydanym Chrome 59.
23
2017-07-27 15: 57: 56Z
  1. Uwielbiałem twoje rozwiązanie ... Chciałbym dać ci +10, ale oto moje +1. Myślę, że można zapisać indeks podciągu, który został zastąpiony, i przejść do następnego, jeśli dopasowanie zostanie znalezione przy niższym indeksie, aby uniknąć tego nieskończonego problemu z pętlą. Nie mogę komentować tego występu, ponieważ nie testowałem go, ale to tylko moje 2cna ten kawałek doskonałości.
    2014-07-10 04: 40: 14Z
  2. @ fr0zenfyr jeśli chcesz sprawdzić, czy pominięcie jest na miejscu (aby zapobiec nieskończonej pętli), możesz wykonać warunkowe, takie jak if(place.replace(omit) === omit) { Brak dopasowania, więc bezpiecznie jest użyć pętli zastępczej } else { Dopasuj więc użyj innej metody, jak split i join }
    2014-07-10 12: 41: 44Z
  3. Hmm .. ale jaki jest sens łączenia dwóch rozwiązań? W każdym razie nie jestem fanem podejścia split /join .. dzięki za radę ..
    2014-07-11 04: 14: 19Z
  4. @ Fr0zenFyr Uważam, że celem połączenia tych dwóch rozwiązań byłoby odrzucenie wolniejszej metody, jeśli nie można użyć szybszego (gdy pętla byłaby nieskończona na przykład). Byłoby więc bezpiecznym zabezpieczeniem funkcjonalności z wydajnością, ale bez możliwości awarii.
    2014-07-11 13: 13: 19Z
  5. Flawed ............
    2017-07-07 09: 52: 19Z
 
str = str.replace(new RegExp("abc", 'g'), "");

działał dla mnie lepiej niż powyższe odpowiedzi. więc new RegExp("abc", 'g') tworzy RegExp, który pasuje do wszystkich wystąpień (flaga 'g') tekstu ("abc"). Druga część jest zamieniana na, w twoim przypadku pusty ciąg ("").  str jest łańcuchem i musimy go zastąpić, ponieważ replace(...) po prostu zwraca wynik, ale nie zastępuje. W niektórych przypadkach możesz chcieć tego użyć.

    
23
2017-12-29 17: 52: 40Z
  1. Chociaż ten fragment kodu może być rozwiązaniem, 2017-12-28 15: 46: 02Z
  2. Tak, masz rację. dodany. edytowałem również, aby odpowiedzieć na oryginalne pytanie :)
    2017-12-29 17: 54: 34Z
  3. Uwaga: Flaga g w wyrażeniu regularnym oznacza, że ​​jest to flaga globalna, która będzie pasować do wszystkich wystąpień
    2018-07-02 16: 15: 50Z

Jeśli to, co chcesz znaleźć, jest już w łańcuchu i nie masz przydatnego escapera, 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'));
    
19
2018-07-23 17: 42: 33Z
 
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;
}
    
17
2014-09-29 19: 17: 45Z
  1. Zastanawiam się, jak dobrze to działa ... podciąg jest rodzimym językiem lub przechodzi przez tablicę char, aby utworzyć nowe znaki.
    2017-07-07 09: 53: 32Z

Podoba mi się ta metoda (wygląda na trochę czystszą):

 
text = text.replace(new RegExp("cat","g"), "dog"); 
    
15
2017-05-27 21: 57: 29Z
    Dobra, jak uciec z łańcucha, aby użyć go jako wzorca wyrażenia regularnego?
    2013-06-19 21: 16: 20Z
  1. Nie używam go tylko do zwykłego tekstu
    2019-03-19 11: 58: 53Z
 
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

    
12
2013-09-04 10: 01: 17Z
  1. jaki był punkt skrzypiec, który zawiera tylko ten sam javascript
    2017-02-08 00: 42: 52Z
 
while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}
    
12
2014-04-29 10: 25: 12Z

Jeśli ciąg zawiera podobny wzór jak abccc, możesz użyć tego:

 
str.replace(/abc(\s|$)/g, "")
    
12
2018-04-27 08: 49: 49Z

Poprzednie odpowiedzi są zbyt skomplikowane. Po prostu użyj funkcji zastępowania w następujący sposób:

 
str.replace(/your_regex_pattern/g, replacement_string);

Przykład:

 
var str = "Test abc test test abc test test test abc test test abc";

var res = str.replace(/[abc]+/g, "");

console.log(res);
    
11
2018-11-18 03: 27: 53Z

Jeśli próbujesz upewnić się, że szukany ciąg nie będzie istnieć nawet po wymianie, musisz użyć pętli.

Na przykład:

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

Po zakończeniu nadal będziesz mieć „test abc”!

Najprostszą pętlą do rozwiązania byłoby:

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

Ale to uruchamia wymianę dwukrotnie dla każdego cyklu. Być może (ryzykując odrzucenie) można je połączyć w nieco bardziej efektywną, ale mniej czytelną formę:

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

Może to być szczególnie przydatne podczas szukania duplikatów ciągów.
Na przykład, jeśli mamy „a , b” i chcemy usunąć wszystkie zduplikowane przecinki.
[W takim przypadku można zrobić .replace (/, + /g, ','), ale w pewnym momencie wyrażenie regularne staje się skomplikowane i wystarczająco powolne, aby zamiast tego wykonać pętlę.]

    
9
2014-09-28 19: 58: 42Z

Chociaż ludzie wspomnieli o użyciu wyrażenia regularnego, ale jest lepsze podejście, jeśli chcesz zastąpić tekst niezależnie od przypadku tekstu. Podobnie 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 odwołać się do szczegółowego przykładu tutaj .

    
9
2016-06-08 18: 51: 40Z
  1. z przykładowej strony: "/toBeReplacedString /gi jest wyrażeniem regularnym, którego należy użyć. Tutaj g reprezentuje dopasowanie globalne, a i oznacza wielkość liter bez znaczenia. Domyślnie wyrażenie regularne to case wrażliwy „
    2016-08-03 10: 15: 16Z

Rozwiązałem ten problem za pomocą prostej linii kodu.

 
str.replace(/Current string/g, "Replaced string");

Sprawdź przykład na jsfiddle https://jsfiddle.net/pot6whnx/1/

    
8
2019-03-07 04: 33: 54Z

Aby zastąpić jednorazowe użycie:

 
var res = str.replace('abc', "");

Aby zastąpić wielokrotnie, użyj:

 
var res = str.replace(/abc/g, "");
    
8
2019-05-29 12: 33: 46Z

Po prostu dodaj /g

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

, aby

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

/g oznacza globalny

    
7
2015-10-15 12: 13: 18Z

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);
};
    
7
2016-02-23 03: 47: 11Z

Następująca funkcja działa dla mnie:

 
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 takie funkcje:

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

Wystarczy skopiować i wkleić ten kod w konsoli przeglądarki do TESTU.

    
7
2018-11-18 03: 32: 37Z
źródło umieszczone tutaj