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

У меня есть эта строка:

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

дела

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

кажется, удаляет только первое вхождение abc в строку выше. Как я могу заменить все его вхождения?

вопрос задан 17.07.2009
Click Upvote
93616 репутация

43 ответов


  • 3664 рейтинг
     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 выше, не предварительно обработав его, чтобы избежать этих символов. Это описано в Руководстве JavaScript для разработчиков Mozilla по регулярным выражениям , в котором представлена ​​следующая функция утилиты:

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

    Поэтому для того , чтобы сделать replaceAll() функции над безопасным, оно может быть изменено на следующее , если вы также включать в себя escapeRegExp :

     function replaceAll(str, find, replace) {
        return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
    }
     
    ответ дан Sean Bright, с репутацией 89870, 17.07.2009
  • 1728 рейтинг

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

    Примечание. Как правило, расширение встроенных прототипов в JavaScript обычно не рекомендуется. Я обеспечиваю в качестве расширений на Струнный прототип просто для целей иллюстрации, показывающие различные варианты реализации гипотетической стандартного метода на String встроенный в прототипе.


    Реализация на основе регулярного выражения

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

    Разделение и объединение (функциональное) выполнение

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

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

    На моей машине Chrome Windows 8 реализация на основе регулярных выражений является самой быстрой , а реализация split и join на 53% медленнее . Значение регулярных выражений в два раза быстрее для ввода lorem ipsum, который я использовал.

    Ознакомьтесь с этим эталоном, в котором выполняются эти две реализации друг против друга.


    Как отмечено в комментарии ниже @ThomasLeduc и другими, может возникнуть проблема с реализацией на основе выражения, если search содержит определенные символы, которые зарезервированы как специальные символы в регулярных выражениях . Реализация предполагает, что вызывающий элемент будет избегать строки заранее или будет передавать только строки, которые не имеют символов в таблице в регулярных выражениях (MDN).

    MDN также обеспечивает реализацию, чтобы избежать наших строк. Было бы неплохо, если бы это было стандартизировано как RegExp.escape(str) , но, увы, его не существует:

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

    Мы могли бы назвать escapeRegExp рамках нашей реализации String.prototype.replaceAll , однако я не уверен, насколько это повлияет на производительность (возможно даже для строк, для которых побег не нужен, как и все буквенно-цифровые строки).

    ответ дан Cory Gross, с репутацией 24500, 12.07.2013
  • 1203 рейтинг

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

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

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

    Общая картина

     str.split(search).join(replacement)
     

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

    ответ дан Matthew Crumley, с репутацией 78981, 17.07.2009
  • 518 рейтинг

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

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

    См. Также

    ответ дан Adam A, с репутацией 10843, 6.05.2009
  • 91 рейтинг

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

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

    РЕДАКТИРОВАТЬ

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

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

    Скрипт: http://jsfiddle.net/cdbzL/

    ответ дан jesal, с репутацией 4930, 11.02.2013
  • 75 рейтинг

    Обновить:

    Это немного поздно для обновления, но поскольку я просто наткнулся на этот вопрос и заметил, что мой предыдущий ответ не тот, которым я доволен. Поскольку вопрос заключался в замене одного слова, невероятно, что никто не думал об использовании границ слов ( \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');
     

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

     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
     
    ответ дан Elias Van Ootegem, с репутацией 55576, 1.03.2012
  • 50 рейтинг

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

     anotherString = someString.replace(/cat/g, 'dog');
     
    ответ дан scronide, с репутацией 9303, 6.05.2009
  • 35 рейтинг
     str = str.replace(/abc/g, '');
     

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

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

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

    EDIT: Уточнение о замене

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

    Например

     var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
    output = output.replaceAll('that', 'this'); //output is 'test this'
     
    ответ дан SolutionYogi, с репутацией 25429, 17.07.2009
  • 30 рейтинг

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

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

    ответ дан Emilio Grisolía, с репутацией 636, 10.09.2016
  • 27 рейтинг

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

     str.replace(/abc/g, '');
     
    ответ дан Donnie DeBoer, с репутацией 2213, 17.07.2009
  • 25 рейтинг

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

     function JavaScriptEncode(text){
        text = text.replace(/'/g,''')
        // More encode here if required
    
        return text;
    }
     
    ответ дан Chris OnDaRocks, с репутацией 812, 19.06.2015
  • 22 рейтинг

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

         function replaceAll(find, replace, str) 
        {
          while( str.indexOf(find) > -1)
          {
            str = str.replace(find, replace);
          }
          return str;
        }
     
    ответ дан Raseela, с репутацией 237, 5.06.2013
  • 20 рейтинг

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

    Пересмотренный 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.
    ответ дан Cole Lawrence, с репутацией 525, 4.04.2014
  • 19 рейтинг
     str = str.replace(new RegExp("abc", 'g'), "");
     

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

    ответ дан csomakk, с репутацией 3710, 28.12.2017
  • 15 рейтинг
    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;
    }
    
    ответ дан Tim Rivoli, с репутацией 151, 29.09.2014
  • 12 рейтинг
     var str = "ff ff f f a de def";
    str = str.replace(/f/g,'');
    alert(str);
     

    http://jsfiddle.net/ANHR9/

    ответ дан pkdkk, с репутацией 1666, 4.09.2013
  • 12 рейтинг
    while (str.indexOf('abc') !== -1)
    {
        str = str.replace('abc', '');
    }
    
    ответ дан zdennis, с репутацией 147, 29.04.2014
  • 12 рейтинг

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

    ответ дан rakslice, с репутацией 5587, 19.06.2013
  • 11 рейтинг

    Использование RegExp в JavaScript могло бы выполнить эту работу для вас, просто выполните следующее:

     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-кода, если вы хотите повторно использовать.

    ответ дан Alireza, с репутацией 39782, 6.06.2017
  • 10 рейтинг

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

     str.replace(/abc(\s|$)/g, "")
     
    ответ дан mostafa elmadany, с репутацией 39, 7.10.2017
  • 10 рейтинг

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

     text = text.replace(new RegExp("cat","g"), "dog"); 
     
    ответ дан Owen, с репутацией 1956, 15.05.2013
  • 9 рейтинг

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

    Например:

     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, ','), но в какой-то момент регулярное выражение становится сложным и достаточно медленным, чтобы зацикливаться.]

    ответ дан SamGoody, с репутацией 8318, 28.09.2014
  • 9 рейтинг
    var string  = 'Test abc Test abc Test abc Test abc'
    string = string.replace(/abc/g, '')
    console.log(string)
    
    ответ дан Ashutosh Narang, с репутацией 126, 9.03.2018
  • 7 рейтинг

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

     /**
     * 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);
    };
     
    ответ дан tk_, с репутацией 6853, 15.02.2016
  • 7 рейтинг

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

     //Consider below example
    originalString.replace(/stringToBeReplaced/gi, '');
    
    //Output will be all the occurrences removed irrespective of casing.
     

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

    ответ дан Cheezy Code, с репутацией 1108, 3.05.2016
  • 7 рейтинг

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

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

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

    ответ дан Victor, с репутацией 2368, 9.10.2013
  • 6 рейтинг

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

     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.

    ответ дан Sandeep Gantait, с репутацией 405, 16.02.2016
  • 6 рейтинг

    Просто добавьте /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 означает глобальное

    ответ дан Reza Fahmi, с репутацией 160, 5.06.2015
  • 5 рейтинг

    Я использую 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'
     
    ответ дан Termininja, с репутацией 4166, 12.01.2016
  • 4 рейтинг

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

     function replaceAll(string, token, newtoken) {
        if(token!=newtoken)
        while(string.indexOf(token) > -1) {
            string = string.replace(token, newtoken);
        }
        return string;
    }
     
    ответ дан Vitim.us, с репутацией 9405, 28.10.2011
  • 4 рейтинг

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

     str = str.replace(/abc/gi, "");
     
    ответ дан Ankit, с репутацией 557, 17.09.2018
  • 4 рейтинг

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

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

    получить:

     http://www.google.com/a%20file%20with%20spaces.html
     
    ответ дан User, с репутацией 7337, 17.03.2017
  • 3 рейтинг

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

     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);
     };
     
    ответ дан SiwachGaurav, с репутацией 1208, 24.12.2013
  • 2 рейтинг

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

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

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

       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 'банан как рапа fraat harvastad naar tha ravar'
    6 'bununu is u ripo frait hurvostod nour tho fivor'
    7 ложных
    8 ложных
    9 'БАНАНА - ПИЩЕВАЯ ПЛОДА, УБЕДИТЕСЬ В РЕЧУ'
    10 'БАНАНА - ИЗОБРАЖЕНИЕ ИЗОБРАЖЕНИЯ,

    ответ дан Paulo Buchsbaum, с репутацией 654, 16.08.2017
  • 2 рейтинг

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

     // Include a reference to the string.js library and call it (for example) S.
    str = S(str).replaceAll('abc', '').s;
     
    ответ дан Guy, с репутацией 29519, 14.09.2014
  • 2 рейтинг
    function replaceAll(str, find, replace) {
        var $r="";
        while($r!=str){ 
            $r = str;
            str = str.replace(find, replace);
        }
        return str;
    }
    
    ответ дан theWalker, с репутацией 1289, 11.04.2016
  • 2 рейтинг

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

     String.prototype.replaceAll = function(find, replace) {
        var str = this;
        return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"), 'g'), replace);
    };
     
    ответ дан Nivesh Saharan, с репутацией 79, 4.03.2016
  • 1 рейтинг

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

    В то время как следующие тесты производительности с использованием 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 петлями - самым медленным.

    ответ дан Ferie, с репутацией 179, 4.09.2018
  • 1 рейтинг

    Я просто хочу поделиться своим решением, основываясь на некоторых функциональных особенностях последних версий 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)
     
    ответ дан Andrés, с репутацией 363, 26.01.2018
  • 1 рейтинг

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

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

    ответ дан TheAivis, с репутацией 151, 11.04.2018
  • 1 рейтинг

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

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

    ответ дан KARTHIKEYAN.A, с репутацией 4075, 28.12.2017
  • 0 рейтинг

    Это можно решить с помощью регулярных выражений и флага 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);
    };
     
    ответ дан C. Morgan, с репутацией 59, 15.10.2016
  • -1 рейтинг

    Попробуй это:

     String.prototype.replaceAll = function (sfind, sreplace) {
        var str = this;
    
        while (str.indexOf(sfind) > -1) {
            str = str.replace(sfind, sreplace);
        }
    
        return str;
    };
     
    ответ дан Antonio Mirarchi, с репутацией 19, 7.01.2014