javascript - Jak nahradím všechny výskyty řetězce?

Vzhledem k řetězci:

string = "Test abc test test abc test test test abc test test abc";

Zdá se, že to odstraní pouze první výskyt abc v uvedeném řetězci:

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

Jak nahradím všechny jeho výskyty?

Odpověď č. 1

Od srpna 2020: Moderní prohlížeče podporují metodu String.replaceAll() definovanou ve specifikaci jazyka ECMAScript 2021.

Pro starší/zastaralé prohlížeče:

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

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

Zde je, jak se tato odpověď vyvíjela:

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

V reakci na komentář „co když je jako proměnná předáno 'abc'?":

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

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

V reakci na komentář Click Upvote byste to mohl ještě více zjednodušit:

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

Poznámka: Regulární výrazy obsahují speciální (meta) znaky, a proto je nebezpečné slepě předávat argument do funkce find výše bez jeho předchozí úpravy k úniku těchto znaků. Toto je popsáno v průvodci JavaScriptem na Mozilla Developer Network, kde představují následující pomocnou funkci (která se od původního napsání této odpovědi změnila nejméně dvakrát, takže se ujistěte, že zkontrolujete stránku MDN pro případné aktualizace):

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

Takže aby byla výše uvedená funkce replaceAll() bezpečnější, mohla by být upravena na následující, pokud také zahrnete escapeRegExp:

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

Odpověď č. 2

Pro úplnost mě napadlo přemýšlet o tom, kterou metodu bych měl použít k tomu, abych to udělal. V zásadě existují dva způsoby, jak to udělat, jak naznačují ostatní odpovědi na této stránce.

Poznámka: Obecně není doporučeno rozšiřovat vestavěné prototypy v JavaScriptu. Poskytuji rozšíření na prototypu String pouze pro ilustrativní účely, ukazující různé implementace hypotetické standardní metody na vestavěném prototypu String.

Implementace založená na regulárních výrazech

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

Implementace rozdělení a spojení (funkcionální)

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

Protože jsem příliš nevěděl o tom, jak regulární výrazy fungují v pozadí z hlediska efektivity, v minulosti jsem měl tendenci spíše používat implementaci pomocí split a join, aniž bych přemýšlel o výkonu. Když jsem si ale kladl otázku, která varianta je efektivnější a o kolik, použil jsem to jako záminku k tomu, abych to zjistil.

Na mém počítači s Chrome a Windows 8 je implementace založená na regulárních výrazech nejrychlejší, přičemž implementace pomocí split a join je o 53 % pomalejší. To znamená, že regulární výrazy jsou dvakrát rychlejší pro použitý vstup lorem ipsum.

Podívejte se na tento benchmark, který porovnává tyto dvě implementace mezi sebou.

Jak bylo poznamenáno v komentáři níže od @ThomasLeduc a dalších, může nastat problém s implementací založenou na regulárních výrazech, pokud search obsahuje určité znaky, které jsou vyhrazené jako speciální znaky v regulárních výrazech. Implementace předpokládá, že volající předem escapuje řetězec, nebo že předá pouze řetězce bez znaků uvedených v tabulce v Regular Expressions (MDN).

MDN také poskytuje implementaci pro escapování našich řetězců. Bylo by fajn, kdyby to bylo také standardizováno jako RegExp.escape(str), ale bohužel to neexistuje:

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

Mohli bychom zavolat escapeRegExp uvnitř naší implementace String.prototype.replaceAll, nicméně si nejsem jistý, jak moc to ovlivní výkon (potenciálně i pro řetězce, u kterých únik není potřeba, jako všechny alfanumerické řetězce).

Odpověď č. 3

V nejnovějších verzích většiny populárních prohlížečů můžete použít replaceAll takto:

let result = "1 abc 2 abc 3".replaceAll("abc", "xyz");
// `result` is "1 xyz 2 xyz 3"

Ale nejdříve zkontrolujte Can I use nebo jinou tabulku kompatibility, abyste si byli jisti, že prohlížeče, na které cílíte, již tuto funkci podporují.

Pro Node.js a kompatibilitu se staršími/neaktuálními prohlížeči:

Poznámka: Tento postup nepoužívejte v kódu kritickém na výkon.

Jako alternativu k regulárním výrazům pro jednoduchý doslovný řetězec můžete použít

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

Obecný vzorec je

str.split(search).join(replacement)

V některých případech to bývalo rychlejší než použití replaceAll a regulárního výrazu, ale zdá se, že u moderních prohlížečů tomu už tak není.

Benchmark: https://jsben.ch/TZYzj

Závěr:

Pokud máte použití, kde je kritická výkonnost (např. zpracování stovek řetězců), použijte metodu s regulárními výrazy. Ale pro většinu typických použití se vyplatí nemuset se starat o speciální znaky.

Odpověď č. 4

Toto jsou nejběžnější a nejsrozumitelnější metody.

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

Metoda 1:

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

Metoda 2:

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

Metoda 3:

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

Metoda 4:

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

Výstup :

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text

Odpověď č. 5

Použijte hranice slov (\b)

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

Toto je jednoduchý regulární výraz, který ve většině případů zabraňuje nahrazování částí slov. Přesto je pomlčka - stále považována za hranici slova. V tomto případě lze tedy použít podmínky, aby se zabránilo nahrazování řetězců jako 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"

V podstatě je tato otázka stejná jako otázka zde: Nahraďte " ' " za " '' " v JavaScriptu

Regexp není jediný způsob, jak nahradit více výskytů podřetězce, zdaleka ne. Myslete flexibilně, myslete na rozdělení!

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

Alternativně, aby se zabránilo nahrazování částí slov—which to schválená odpověď také udělá! Tento problém můžete obejít pomocí regulárních výrazů, které jsou, přiznávám, poněkud složitější a v důsledku toho také o něco pomalejší:

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

Výstup je stejný jako u přijaté odpovědi, nicméně použití výrazu /cat/g na tomto řetězci:

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, tohle opravdu pravděpodobně není to, co chcete. Co tedy je? Podle mého názoru regulární výraz, který nahrazuje 'cat' pouze podmíněně (tzn. není součástí slova), například takto:

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"

Myslím, že toto splní vaše potřeby. Samozřejmě to není zaručené, ale mělo by to stačit na to, abyste začali. Doporučil bych přečíst si více na těchto stránkách. To se ukáže jako užitečné při zdokonalování tohoto výrazu tak, aby vyhovoval vašim specifickým potřebám.

• Objekt RegExp (regulární výraz)

• Regular-Expressions.info

Zde je příklad použití .replace s callback funkcí. V tomto případě výraz výrazně zjednodušuje a zároveň poskytuje ještě větší flexibilitu, například nahrazení s správnou kapitalizací nebo nahrazení jak cat, tak cats najednou:

'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

Odpověď č. 6

Porovnat podle globálního regulárního výrazu:

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

Odpověď č. 7

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

Nebo vyzkoušejte metodu replaceAll, jak je doporučeno v této odpovědi:

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

nebo :

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

ÚPRAVA: Ujasnění ohledně dostupnosti replaceAll

Metoda replaceAll je přidána do prototypu String. To znamená, že bude dostupná pro všechny objekty/retezce typu string.

Příklad :

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

Odpověď č. 8

Použijte regulární výraz:

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

Odpověď č. 9

Výkon

Dnes 27.12.2019 provádím testy na macOS v10.13.6 (High Sierra) pro zvolená řešení.

Závěry

• str.replace(/abc/g, ''); (C) je dobré rychlé řešení kompatibilní mezi prohlížeči pro všechny řetězce.
• Řešení založená na split-join (A,B) nebo replace (C,D) jsou rychlá
• Řešení založená na while (E,F,G,H) jsou pomalá - obvykle ~4krát pomalejší pro malé řetězce a asi ~3000krát (!) pomalejší pro dlouhé řetězce
• Řešení rekurence (RA,RB) jsou pomalá a nefungují pro dlouhé řetězce

Také vytvářím své vlastní řešení. Vypadá to, že momentálně je to nejkratší, které řeší danou otázku:

str.split`abc`.join``

str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);

Detaily

Testy byly provedeny na Chrome 79.0, Safari 13.0.4 a Firefox 71.0 (64 bit). Testy RA a RB používají rekurzi. Výsledky

Krátký řetězec - 55 znaků

Můžete spustit testy na svém zařízení ZDE. Výsledky pro Chrome:

Dlouhý řetězec: 275 000 znaků

Rekurzivní řešení RA a RB poskytují

RangeError: Překročena maximální velikost zásobníku volání

Pro 1 milion znaků dokonce dokáží zničit Chrome

Snažím se provádět testy pro 1 milion znaků pro jiné řešení, ale E,F,G,H trvá tak dlouho, že mě prohlížeč vyzve k přerušení skriptu, takže jsem testovací řetězec zkrátil na 275 tisíc znaků. Testy můžete spustit na svém počítači ZDE. Výsledky pro Chrome

Kód použitý v testech

var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) => console.log(`${version}: ${result}`);


function A(str) {
  return str.split('abc').join('');
}

function B(str) {
  return str.split`abc`.join``; // my proposition
}


function C(str) {
  return str.replace(/abc/g, '');
}

function D(str) {
  return str.replace(new RegExp("abc", "g"), '');
}

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

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

function G(str) {
  while(str.includes("abc")) { str = str.replace('abc', ''); }
  return str;
}

// src: https://stackoverflow.com/a/56989553/860099
function H(str)
{
    let i = -1
    let find = 'abc';
    let newToken = '';

    if (!str)
    {
        if ((str == null) && (find == null)) return newToken;
        return str;
    }

    while ((
        i = str.indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    }
    return str;
}

// src: https://stackoverflow.com/a/22870785/860099
function RA(string, prevstring) {
  var omit = 'abc';
  var place = '';
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return RA(prevstring, string)
}

// src: https://stackoverflow.com/a/26107132/860099
function RB(str) {
  var find = 'abc';
  var 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) + RB(st2, find, replace);
    }
  }
  return str;
}




log('A ', A(t));
log('B ', B(t));
log('C ', C(t));
log('D ', D(t));
log('E ', E(t));
log('F ', F(t));
log('G ', G(t));
log('H ', H(t));
log('RA', RA(t)); // use reccurence
log('RB', RB(t)); // use reccurence

<p style="color:red">This snippet only presents codes used in tests. It not perform test itself!<p>

Odpověď č. 10

Opakujte to, dokud počet výskytů nedosáhne 0, takto:

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

Odpověď č. 11

Toto je nejrychlejší verze, která nepoužívá regulární výrazy.

Upravený jsperf

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

Je téměř dvakrát rychlejší než metoda dělení a spojování.

Jak bylo zmíněno v komentáři zde, toto nebude fungovat, pokud vaše proměnná omit obsahuje place, například: replaceAll("string", "s", "ss"), protože vždy bude schopna nahradit další výskyt slova.

Existuje další jsperf s variantami mé rekurzivní nahrazovací funkce, které jsou ještě rychlejší (http://jsperf.com/replace-all-vs-split-join/12)!

• Aktualizace 27. července 2017: Vypadá to, že RegExp nyní má nejrychlejší výkon v nedávno vydaném Chrome 59.

Odpověď č. 12

Pokud to, co chcete najít, je již v řetězci, a nemáte po ruce escapovač regulárních výrazů, můžete použít 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'));

Odpověď č. 13

Samozřejmě v 2021 je správná odpověď:

String.prototype.replaceAll()

console.log(
  'Change this and this for me'.replaceAll('this','that') // Normal case
);
console.log(
  'aaaaaa'.replaceAll('aa','a') // Challenged case
);

Pokud se nechcete zabývat replace() + RegExp.

A co když je prohlížeč z období před rokem 2020?

V tomto případě potřebujeme polyfill (nucení starších prohlížečů podporovat nové funkce) (myslím, že několik let to bude nutné). Nemohl jsem najít úplně správnou metodu v odpovědích. Takže navrhuji tuto funkci, která bude definována jako polyfill.

Moje navrhované možnosti polyfillu pro replaceAll:

polyfill replaceAll (s chybou globálního příznaku) (více principovaná verze)

if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : function(){throw new TypeError('replaceAll called with a non-global RegExp argument')}() // If not throw an error
                    : RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}

replaceAll polyfill (s podporou chybějícího globálního flagu) (moje první volba) - Proč?

if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : RegExp(search.source, /\/([a-z]*)$/.exec(search.toString())[1] + 'g') // If not, make a global clone from the RegEx
                    : RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}

Minimalizováno (má první volba):

if(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:RegExp(search.source,/\/([a-z]*)$/.exec(search.toString())[1]+'g'):RegExp(String(search).replace(/[.^$*+?()[{|\\]/g,"\\$&"),"g"),replace)}})}

Vyzkoušej to:

if(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:RegExp(search.source,/\/([a-z]*)$/.exec(search.toString())[1]+'g'):RegExp(String(search).replace(/[.^$*+?()[{|\\]/g,"\\$&"),"g"),replace)}})}

console.log(
  'Change this and this for me'.replaceAll('this','that')
); // Change that and that for me

console.log(
  'aaaaaa'.replaceAll('aa','a')
); // aaa

console.log(
  '{} (*) (*) (RegEx) (*) (\*) (\\*) [reserved characters]'.replaceAll('(*)','X')
); // {} X X (RegEx) X X (\*) [reserved characters]

console.log(
  'How (replace) (XX) with $1?'.replaceAll(/(xx)/gi,'$$1')
); // How (replace) ($1) with $1?

console.log(
  'Here is some numbers 1234567890 1000000 123123.'.replaceAll(/\d+/g,'***')
); // Here is some numbers *** *** *** and need to be replaced.

console.log(
  'Remove numbers under 233: 236   229  711   200   5'.replaceAll(/\d+/g, function(m) {
    return parseFloat(m) < 233 ? '' : m
  })
); // Remove numbers under 233: 236     711

console.log(
  'null'.replaceAll(null,'x')
); // x


// The difference between My first preference and the original:
// Now in 2022 with browsers > 2020 it should throw an error (But possible it be changed in future)

//   console.log(
//      'xyz ABC abc ABC abc xyz'.replaceAll(/abc/i,'')
//   );

// Browsers < 2020:
// xyz     xyz
// Browsers > 2020
// TypeError: String.prototype.replaceAll called with a non-global RegExp

Podpora prohlížeče:

• Internet Explorer 9 a novější (založeno na Internet Explorer 11).
• Všechny ostatní prohlížeče (po roce 2012).

Výsledek je stejný jako u nativní metody replaceAll v případě, že první argument je: null, undefined, Object, Function, Date, ... , RegExp, Number, String, ...

Odkaz: 22.1.3.19 String.prototype.replaceAll ( searchValue, replaceValue) + Syntaxe RegExp

Důležitá poznámka: Jak někteří odborníci uvádějí, mnoho rekurzivních funkcí, které byly navrženy v odpovědích, vrátí špatný výsledek. (Vyzkoušejte je s problematickým případem výše uvedeného úryvku.) Možná některé složité metody jako .split('searchValue').join('replaceValue') nebo některé dobře spravované funkce dají stejný výsledek, ale rozhodně s mnohem nižším výkonem než native replaceAll()/polyfill replaceAll()/replace() + RegExp

Jiné metody přiřazení polyfillu

Naivní, ale podporuje i starší prohlížeče (je lepší se tomu vyhnout)

Například můžeme podporovat i IE7+, tím, že nepoužijeme Object.defineProperty() a použijeme moji starou naivní metodu přiřazení:

if (!String.prototype.replaceAll) {
    String.prototype.replaceAll = function(search, replace) { // <-- Naive method for assignment
        // ... (Polyfill code Here)
    }
}

A mělo by to dobře fungovat pro základní použití na IE7+.
Ale jak zde vysvětlil @sebastian-simon, to může způsobit sekundární problémy v případě pokročilejšího použití. Např.:

for (var k in 'hi') console.log(k);
// 0
// 1
// replaceAll  <-- ?

Plně důvěryhodný, ale těžký

Ve skutečnosti je má navrhovaná možnost trochu optimistická. Jako bychom důvěřovali prostředí (prohlížeči a Node.js), je to rozhodně pro období kolem let 2012-2021. Také je to standardní/slavná možnost, takže to nevyžaduje žádné speciální zvážení.

Ale mohou existovat ještě starší prohlížeče nebo nějaké neočekávané problémy, a polyfily stále mohou podporovat a řešit více možných problémů prostředí. Takže v případě, že potřebujeme maximální podporu, která je možná, můžeme použít polyfill knihovny jako:

https://polyfill.io/

Speciálně pro replaceAll:

<script src="https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll"></script>

Odpověď č. 14

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

Odpověď č. 15

Líbí se mi tato metoda (vypadá o něco čistěji):

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

Odpověď č. 16

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

Odpověď č. 17

K srpnu 2020 existuje návrh fáze 4 na ECMAScript, který přidává metodu replaceAll do String.

Nyní je podporováno v Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+.

Použití je stejné jako u metody replace:

String.prototype.replaceAll(searchValue, replaceValue)

Zde je příklad použití:

'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -> 'Test foo test test foo test.'

Je podporováno ve většině moderních prohlížečů, ale existují polyfily:

• core-js
• es-shims

Je podporováno v enginu V8 za experimentálním přepínačem --harmony-string-replaceall. Více si přečtěte na webu V8.

Odpověď č. 18

Pokud řetězec obsahuje podobný vzor jako abccc, můžete použít toto:

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

Odpověď č. 19

Předchozí odpovědi jsou příliš složité. Jednoduše použijte funkci replace takto:

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

Příklad :

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

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

console.log(res);

Odpověď č. 20

Po několika pokusech a spoustě neúspěchů jsem zjistil, že níže uvedená funkce se zdá být nejlepší univerzální volbou, pokud jde o kompatibilitu s prohlížeči a snadnost použití. Toto je jediné fungující řešení pro starší prohlížeče, které jsem našel. (Ano, i když jsou staré prohlížeče nedoporučované a zastaralé, některé starší aplikace stále hojně využívají OLE prohlížeče (například staré aplikace ve Visual Basicu 6 nebo makra Excel .xlsm s formuláři).

Každopádně, tady je jednoduchá funkce.

function replaceAll(str, match, replacement){
   return str.split(match).join(replacement);
}

Odpověď č. 21

Ačkoli lidé zmínili použití regulárních výrazů, existuje lepší přístup, pokud chcete text nahradit bez ohledu na velikost písmen. Například velká nebo malá písmena. Použijte následující syntaxi:

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

// The output will be all the occurrences removed irrespective of casing.

Můžete se zde odkazovat na podrobný příklad.

Odpověď č. 22

Pokud se snažíte zajistit, aby řetězec, který hledáte, neexistoval ani po nahrazení, musíte použít cyklus.

Například:

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

Po dokončení budete stále mít 'test abc'!

Nejjednodušší cyklus, jak to vyřešit, by byl:

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

Ale to spouští nahrazení dvakrát během každého cyklu. Možná (s rizikem, že bude odmítnuto) by to šlo zkombinovat pro mírně efektivnější, ale méně čitelnou formu:

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

To může být zvláště užitečné při hledání duplicitních řetězců.
Například pokud máme 'a,,,b' a chceme odstranit všechny duplicitní čárky.
[V takovém případě by šlo použít .replace(/,+/g,','), ale v určitém bodě se regulární výraz stává složitým a pomalým, takže je lepší použít smyčku.]