Как заменить все вхождения строки в JavaScript

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

В ответ на комментарий:

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

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

В ответ на комментарий Click Upvote вы можете упростить его еще больше:

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

Примечание.. Регулярные выражения содержат специальные (мета) символы и, как таковые, опасно слепо передать аргумент в функции find выше, не предварительно обработав его, чтобы избежать этих символов. Это описано в Mozilla Developer Network Руководство по регулярным выражениям JavaScript, где они представляют следующую служебную функцию:

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

Итак, чтобы сделать функцию replaceAll() выше безопасной, ее можно было бы изменить следующим образом, если вы также включили escapeRegExp:

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

Примечание. Не используйте это в реальном коде.

В качестве альтернативы регулярным выражениям для простой литеральной строки вы можете использовать

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

Общий шаблон

str.split(search).join(replacement)

В некоторых случаях это было быстрее, чем использование replaceAll и регулярное выражение, но в современных браузерах это, похоже, не так. Таким образом, это действительно должно быть использовано только как быстрый хак, чтобы избежать необходимости избегать регулярного выражения, а не реального кода.

Использование регулярного выражения с установленным флагом g заменит все:

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

См. также

Здесь строковая прототипная функция, основанная на принятом ответе:

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

EDIT

Если ваш find будет содержать специальные символы, вам необходимо их избежать:

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

Fiddle: http://jsfiddle.net/cdbzL/

Обновить:

Он немного опоздал на обновление, но так как я просто наткнулся на этот вопрос и заметил, что мой предыдущий ответ не тот, которым я доволен. Поскольку вопрос заключался в замене одного слова, невероятно, что никто не думал об использовании границ слов (\b)

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

Это простое регулярное выражение, которое позволяет избежать замены частей слов в большинстве случаев. Тем не менее, тире - все еще считается границей слова. Поэтому условные обозначения можно использовать в этом случае, чтобы избежать замены строк, таких как 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"

в основном, этот вопрос такой же, как и здесь: Javascript заменить "" на "" "

@Mike, проверьте ответ, который я дал там... regexp - это не единственный способ заменить несколько вхождений подстроки, далеко от нее. Подумайте о гибкости, подумайте, разделите!

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

В качестве альтернативы, чтобы предотвратить замену частей слова -which, также будет принят одобренный ответ! Вы можете обойти эту проблему, используя регулярные выражения, которые, я признаю, несколько более сложны и, как следствие, еще медленнее:

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

Результат такой же, как и принятый ответ, однако, используя выражение /cat/g в этой строке:

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

На самом деле, это, вероятно, не то, что вы хотите. Что же тогда? IMHO, регулярное выражение, которое заменяет "cat" условно. (т.е. не является частью слова), например:

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

Окончательное дополнение:

Учитывая, что этот вопрос по-прежнему имеет много точек зрения, я подумал, что могу добавить пример .replace используемый с функцией обратного вызова. В этом случае это значительно упрощает выражение и обеспечивает еще большую гибкость, например, замену правильной капитализацией или замену cat и cats за один раз:

'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

Соответствует глобальному регулярному выражению:

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

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

Или попробуйте функцию replaceAll отсюда:

Каковы полезные методы JavaScript, которые расширяют встроенные объекты?

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

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

РЕДАКТИРОВАТЬ: Разъяснение относительно доступности replaceAll

Метод replaceAll добавляется к прототипу String. Это означает, что он будет доступен для всех строковых объектов/литералов.

например.

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

Предположим, вы хотите заменить все "abc" на "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

Я пытался думать о чем-то более простом, чем модифицировать прототип строки.

Используйте регулярное выражение:

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

Замена одиночных кавычек:

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

    return text;
}

//зацикливать его до появления числа в 0. ИЛИ просто скопировать/вставить

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

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

работал лучше для меня, чем вышеупомянутые ответы. поэтому new RegExp("abc", 'g') создает RegExp, что соответствует всему присутствию (флаг 'g') текста ("abc"). Вторая часть - это то, что заменяется на, в вашем случае пустую строку (""). str - это строка, и мы должны ее переопределить, так как replace(...) просто возвращает результат, но не переопределяет. В некоторых случаях вы можете использовать это.

Это самая быстрая версия, которая не использует регулярные выражения.

Пересмотренный jsperf

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

Это почти дважды так же быстро, как метод split и join.

Как указано в комментарии здесь, это не будет работать, если ваша переменная omit содержит place, как в: replaceAll("string", "s", "ss"), потому что она всегда сможет заменить другое вхождение этого слова.

Существует еще один jsperf с вариантами на моей рекурсивной замене, которые идут еще быстрее (http://jsperf.com/replace-all-vs-split-join/12)!

• Обновление 27 июля 2017 года. Похоже, что RegExp теперь имеет самую быструю производительность в недавно выпущенном Chrome 59.

Использование RegExp в JavaScript может сделать всю работу за вас, просто сделайте что-то вроде ниже, не забывайте /g после которого выделяется глобальное:

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

Если вы думаете о повторном использовании, создайте функцию, которая сделает это за вас, но это не рекомендуется, так как это всего лишь одна строчная функция, но, опять же, если вы интенсивно ее используете, вы можете написать что-то вроде этого:

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

и просто используйте его в своем коде снова и снова, как показано ниже:

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

Но, как я упоминал ранее, это не будет иметь большого значения с точки зрения написания строк или производительности, только кэширование функции может повлиять на более высокую производительность на длинных строках, а также на хорошую практику DRY-кода, если вы захотите использовать повторно.

Если то, что вы хотите найти, уже находится в строке, и у вас нет регулярного выражения escaper, вы можете использовать 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'));

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

Мне нравится этот метод (он выглядит немного чище):

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

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

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

http://jsfiddle.net/ANHR9/

Если строка содержит аналогичный шаблон, такой как abccc, вы можете использовать это:

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

Предыдущие ответы слишком сложны. Просто используйте функцию замены следующим образом:

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

Пример:

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

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

console.log(res);

Просто следуйте этому регулярному выражению oneliner, добавляя чувствительность к регистру, поэтому, если вы делаете "ABC", он будет действовать так же, как и для "abc".

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

Если вы пытаетесь убедиться, что строка, которую вы ищете, не будет существовать даже после замены, вам нужно использовать цикл.

Например:

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

Когда вы закончите, у вас все равно будет "test abc"!

Самый простой цикл для решения этого вопроса:

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

Это может быть особенно полезно при поиске повторяющихся строк.
Например, если у нас есть "a,, b", и мы хотим удалить все дубликаты запятых.
[В этом случае можно было бы сделать .replace(/, +/g, ','), но в какой-то момент регулярное выражение становится сложным и достаточно медленным, чтобы зацикливаться.]

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

Хотя люди упоминали об использовании регулярных выражений, но есть лучший подход, если вы хотите заменить текст независимо от случая текста. Как прописные или строчные буквы. Использовать синтаксис ниже

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

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

Вы можете сослаться на подробный пример здесь.

У меня работает следующая функция:

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

Теперь вызовите функции так:

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

Просто скопируйте и вставьте этот код из консоли браузера в TEST.

Вы можете просто использовать ниже метод

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

Просто добавьте /g

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

к

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

/g означает глобальный

Вы можете попробовать объединить эти два мощных метода.

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

Надеюсь, поможет!

Я использую p, чтобы сохранить результат предыдущей замены рекурсии:

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

Он заменит все вхождения в строке s, пока это не будет возможно:

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

Чтобы избежать бесконечного цикла, я проверяю, содержит ли замена r совпадение m:

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

Большинство людей, вероятно, делают это для кодирования URL-адреса. Чтобы закодировать URL-адрес, вы должны не только рассматривать пробелы, но и правильно преобразовывать всю строку с помощью encodeURI.

encodeURI("http://www.google.com/a file with spaces.html")

чтобы получить:

http://www.google.com/a%20file%20with%20spaces.html

Что касается производительности, связанной с основными ответами , то это некоторые онлайн-тесты.

Ниже приведены некоторые тесты производительности с помощью console.time() (они лучше всего работают на вашей собственной консоли, время очень короткое, что можно увидеть в фрагменте)

console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')

console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');

console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
    str1 = str1.replace('-', ' ');
}
console.timeEnd('while');

Интересно отметить, что если вы запускаете их несколько раз, результаты всегда разные, хотя решение RegExp кажется самым быстрым в среднем, а решение while while - самым медленным.

Для замены всех типов символов попробуйте этот код:

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

Таким образом, этот метод решит эту проблему.

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

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

Я использовал Ajax, и мне нужно было отправлять параметры в формате JSON. Тогда мой метод выглядит следующим образом:

 function sendMessage(source, messageID, toProfileID, userProfileID) {

     if (validateTextBox()) {
         var message = $('#message').val();
         message = message.replaceAll('\\', '\\\\');
         message = message.replaceAll('"', '\\"');
         $.ajax({
             type: "POST",
             async: "false",
             contentType: "application/json; charset=utf-8",
             url: "services/WebService1.asmx/SendMessage",
             data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").hide();
                 $("#message").val("");
                 $("#delMessageContainer").show();
                 $("#msgPanel").show();
             },
             error: function (result) {
                 alert("message sending failed");
             }
         });
     }
     else {
         alert("Please type message in message box.");
         $("#message").focus();

     }
 }

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

Моя реализация, очень понятная

function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}

В моих приложениях я использую настраиваемую функцию, которая является самой мощной для этой цели, и даже обертывание решения split/join в более простом случае, это немного быстрее в Chrome 60 и Firefox 54 (JSBEN.CH), чем другие решения. Мой компьютер работает Windows 7 64 bits.

Преимущество заключается в том, что эта настраиваемая функция может обрабатывать множество подстановок одновременно с использованием строк или символов, что может быть ярлыком для некоторых приложений.

Как и решение split/join выше, нижеприведенное решение не имеет проблем с escape-символами, иначе чем подход к регулярному выражению.

  function replaceAll(s,find,repl,caseOff,byChar){
  if (arguments.length<2)  return false; 
  var destDel = ! repl;       // if destDel delete all keys from target
  var isString = !! byChar;   // if byChar, replace set of characters 
  if (typeof find !==typeof repl && ! destDel)  return false; 
  if (isString  &&  (typeof find!=="string"))   return false; 

  if (! isString &&  (typeof find==="string"))  {
    return s.split(find).join(destDel?"":repl);
  }

  if ((! isString)  &&  ( ! Array.isArray(find) ||
          ( ! Array.isArray(repl) && ! destDel)   ))  return false;

     // if destOne replace all strings/characters by just one element
  var destOne = destDel ? false : (repl.length===1);   

     // Generally source and destination should have the same size
  if (! destOne && ! destDel && find.length!==repl.length)  return false    

  var prox,sUp,findUp,i,done;   
  if (caseOff)  {    // case insensitive    
       // Working with uppercase keys and target 
    sUp = s.toUpperCase();   
    if (isString)
       findUp = find.toUpperCase()   
    else
       findUp = find.map(function(el){  return el.toUpperCase();});    

  } else  {         // case sensitive
     sUp = s;
     findUp =find.slice();  // clone array/string
  }  

  done = new Array(find.length);  // size: number of keys
  done.fill(null);              

  var pos = 0;       // initial position in target s
  var r = "";   // initial result
  var aux, winner;
  while (pos < s.length)  {       // Scanning the target
     prox  = Number.MAX_SAFE_INTEGER;
     winner = -1;  // no winner at start
     for (i=0;i<findUp.length;i++)   // find next occurence for each string
       if (done[i]!==-1) {    // key still alive
             // Never search for the word/char or is over?
         if (done[i]===null || done[i]<pos)  { 
           aux = sUp.indexOf(findUp[i],pos);
           done[i]=aux;  // Save the next occurrence
         } else
           aux = done[i]   // restore the position of last search
         if (aux<prox && aux!==-1) {   // if next occurrence is minimum
           winner = i;     // save it  
           prox = aux;
         }  
       }  // not done

      if (winner===-1) {   // No matches forward
         r += s.slice(pos);   
         break;
      } // no winner

      // found the character or string key in the target

      i = winner;  // restore the winner
      r += s.slice(pos,prox);   // update piece before the match

            // Append the replacement in target 
      if (! destDel) r += repl[ destOne?0:i ];  
      pos = prox + ( isString?1:findUp[i].length );       // go after match

  }  // loop
  return r;  // return the resulting string
}

Документация ниже

           replaceAll    
 Syntax    
 ======     
      replaceAll(s,find,[ repl ,caseOff, byChar)     

 Parameters    
 ==========    

   "s" is a string target of replacement.    
   "find" can be a string or array of strings.     
   "repl" should be the same type than "find" or empty     

  if "find" is a string, it is a simple replacement for      
    all "find" occurrences in "s" by string "repl"    

  if "find" is an array, it will replaced each string in "find"    
    that occurs in "s" for corresponding string in "repl" array.
  The replace specs are independent: A replacement part cannot    
    be replaced again. 


  if "repl" is empty all "find" occurrences in "s" will be deleted.   
  if "repl" has only one character or element,    
      all occurrences in "s" will be replaced for that one.   

  "caseOff" is true if replacement is case insensitive     
       (default is FALSE)

  "byChar" is true when replacement is based on set of characters.    
  Default is false   

  if "byChar", it will be replaced in "s" all characters in "find"   
  set of characters for corresponding character in  "repl"
  set of characters   

 Return   
 ======   
  the function returns the new string after the replacement.  

Чтобы быть справедливым, я провел тест без проверки параметров.

Вот мой тестовый набор, используя Node.js

function l() { return console.log.apply(null, arguments); }

var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa"]));  //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do"]));  //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"]));  //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
     "aeiou","","",true));  //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","a","",true));  //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoiea","",true));  //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoi","",true));  //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa","leg"]));  //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"]));  //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"],true)); //10
return;

И результаты:

1 'банан - это плод, собранный в далеком будущем "
2" банан - это плод, собранный в допинге, дольщик "3 'банан - это плод, заготовленный r ver'
4 'bnn s rp frt hrvstd nr th rvr'
5 'банан как рапа-фраат харвастад наар та равар'
6 'bununu is u ripo frait hurvostod nour tho rivor'
7 ложных
8 ложных
9 'БАНАНА - ПИЩЕВАЯ ПЛОДА, УБЕДИТЕСЬ ВБЛИЗИ РЕКИ"
10 'BANANA - ИЗОБРАЖЕНИЕ ИЗОБРАЖЕНИЯ ИЗОБРАЖЕНИЙ, КОТОРОЕ ЗАВЕРШЕНО

function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}

Вот рабочий код с прототипом:

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

Для уникальных сменных значений

String.prototype.replaceAll = function(search_array, replacement_array) {
  //
  var target = this;
  //
  search_array.forEach(function(substr, index) {
    if (typeof replacement_array[index] != "undefined") {
      target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
    }
  });
  //
  return target;
};

//  Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);

В поиске и замене первого элемента строки

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

В строке глобального поиска и замены

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

Если использование библиотеки является для вас вариантом, вы получите преимущества тестирования и поддержки сообщества, которые идут с библиотечной функцией. Например, библиотека string.js имеет функцию replaceAll(), которая делает то, что вы ищете:

// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;

Я просто хочу поделиться своим решением, основанным на некоторых функциональных возможностях последних версий JavaScript:

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

   var result = str.split(' ').reduce((a, b) => {
      return b == 'abc' ? a : a + ' ' + b;   })

  console.warn(result)

Это можно решить с помощью регулярных выражений и флага g, что означает не останавливаться после поиска первого совпадения. Действительно, регулярные выражения - спасатели жизни!

function replaceAll(string, pattern, replacement) {
    return string.replace(new RegExp(pattern, "g"), replacement);
}

// or if you want myString.replaceAll("abc", "");

String.prototype.replaceAll = function(pattern, replacement) {
    return this.replace(new RegExp(pattern, "g"), replacement);
};

Способ 1

Попробуйте реализовать регулярное выражение

"Тест abc тест, тест abc тест, тест, тест abc, тест, тест abc".replace(/\ abc/g, '');

Способ 2

Разделить и присоединиться. Разделить с помощью abc и объединить с пустым пространством

"Test abc test abc test test test abc test test abc".split("abc"). Join ("")

Попробуйте следующее:

String.prototype.replaceAll = function (sfind, sreplace) {
    var str = this;

    while (str.indexOf(sfind) > -1) {
        str = str.replace(sfind, sreplace);
    }

    return str;
};

Вы можете попробовать так:

пример данных:

var text = "heloo,hai,hei"

text = text.replace(/[,]+/g,'')

или же

text.forEach(function(value){
  hasil = hasil.replace(',','')
})'''