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

Обновление: в последних версиях большинства популярных браузеров вы можете использовать _ 1_, как показано здесь:

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

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

Для Node и совместимости со старыми / устаревшими браузерами:

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

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

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

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

str.split(search).join(replacement)

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

Тест: https://jsben.ch/TZYzj

Заключение: если у вас есть критический для производительности вариант использования (например, обработка сотен строк), используйте метод Regexp. Но для большинства типичных случаев использования не стоит беспокоиться о специальных символах.

По состоянию на август 2020 г .: современные браузеры поддерживают _ 1_ метод, определенный спецификацией языка ECMAScript 2021.

Для старых / устаревших браузеров:

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 Guide on Regular Expressions, где они представляют следующую служебную функцию (которая, по крайней мере, изменилась дважды с тех пор, как этот ответ был изначально написан, поэтому обязательно проверьте сайт MDN на наличие потенциальных обновлений):

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

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

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

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

Примечание. Как правило, расширение встроенных прототипов в JavaScript не рекомендуется. Я предоставляю в качестве расширений прототипа String просто в целях иллюстрации, показывая различные реализации гипотетического стандартного метода на встроенном прототипе 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 реализация на основе регулярных выражений является самой быстрой, а реализация разделения и объединения выполняется на 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, однако я не уверен, насколько это повлияет на производительность (возможно, даже для строк, для которых экранирование не требуется, как и для всех буквенно-цифровых строк).

Использование регулярного выражения с установленным флагом 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);
};

ИЗМЕНИТЬ

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

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

Скрипка: 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 replace 'with' '

@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

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

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

Для замены одноразового использования:

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

Для многократной замены используйте:

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

Это наиболее распространенные и удобочитаемые методы.

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

Метод 1:

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

Метод 2:

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

Метод 3:

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

Метод 4:

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

Выход:

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

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

Или попробуйте метод replaceAll, как рекомендовано в этом ответе < / а>:

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

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

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

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

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

Скажем, вы хотите заменить все буквы 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;
}

Представление

Сегодня, 27.12.2019, я провожу тесты на macOS v10.13.6 (High Sierra) для выбранных решений.

Выводы

• str.replace(/abc/g, ''); (C) - хорошее кроссбраузерное быстрое решение для всех строк.
• Решения, основанные на split-join (A, B) или replace (C, D), быстро
• Решения на основе while (E, F, G, H) медленные - обычно в ~ 4 раза медленнее для небольших строк и примерно в ~ 3000 раз (!) Медленнее для длинных строк.
• Решения для повторения (RA, RB) медленные и не работают для длинных строк.

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

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

Подробности

Тесты проводились в Chrome 79.0, Safari 13.0.4 и Firefox 71.0 (64 бит). В тестах RA и RB используется рекурсия. Полученные результаты

Короткая строка - 55 символов

Вы можете запустить тесты на своем компьютере ЗДЕСЬ. Результаты для Chrome:

Длинная строка: 275 000 символов

Рекурсивные решения RA и RB дают

RangeError: превышен максимальный размер стека вызовов

Для 1M персонажей они даже ломают Chrome

Я пытаюсь выполнить тесты для 1M символов для других решений, но E, F, G, H занимает так много времени, что браузер просит меня прервать скрипт, поэтому я сокращаю тестовую строку до 275K символов. Вы можете запустить тесты на своем компьютере ЗДЕСЬ. Результаты для Chrome

Код, используемый в тестах

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>

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

Это почти вдвое быстрее, чем метод разделения и объединения.

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

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

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

Цикл, пока число вхождений не дойдет до 0, например:

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

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

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

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

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

http://jsfiddle.net/ANHR9/

Самый простой способ сделать это без использования регулярных выражений - разделить и объединить, как в приведенном здесь коде:

var str = "Test abc test test abc test test test abc test test abc";
console.log(str.split('abc').join(''));

Если строка содержит аналогичный шаблон, например 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);

По состоянию на август 2020 года в ECMAScript есть этап 4, который добавляет _ 1_ к String.

Теперь он поддерживается в Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+.

Используется так же, как _3 _ метод:

String.prototype.replaceAll(searchValue, replaceValue)

Вот пример использования:

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

Он поддерживается в большинстве современных браузеров, но существуют полифиллы:

• core-js
• es-shims

Он поддерживается в движке V8 за экспериментальным флагом --harmony-string-replaceall. Дополнительные сведения см. На веб-сайте V8.

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

Например:

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

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

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

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

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

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

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

to

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

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

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

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

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

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

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

Проверьте этот ответ, может он поможет, и я использовал в своем проекте.

function replaceAll(searchString, replaceString, str) {
   return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test  test test  test test test  test test "

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

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

Я использую 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'

Чтобы заменить все символы, попробуйте этот код:

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( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}

Этого можно добиться с помощью регулярных выражений. Несколько комбинаций, которые могут кому-то помочь:

var word = "this,\\ .is*a*test,    '.and? / only /     'a \ test?";
var stri = "This      is    a test         and only a        test";

Чтобы заменить все символы, отличные от букв,

console.log(word.replace(/([^a-z])/g,' ').replace(/ +/g, ' ')); 
Result: [this is a test and only a test]

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

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

Чтобы заменить все символы *,

console.log(word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

Чтобы заменить вопросительные знаки (?)

console.log(word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

Чтобы заменить кавычки,

console.log(word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

Чтобы заменить все символы ",

console.log(word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

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

console.log(word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

Чтобы заменить обратную косую черту

console.log(word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

Чтобы заменить косую черту

console.log(word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

Чтобы заменить все пробелы

console.log(word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

Чтобы заменить точки,

console.log(word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]

Метод 1

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

«Тест abc test test abc test test test abc test test abc» .replace (/ \ abc / g, '');

Способ 2

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

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

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

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

получить:

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

В своих приложениях я использую специальную функцию, которая является самой мощной для этой цели, и даже оборачивая решение split/join в более простом случае, оно немного быстрее в Chrome 60 и Firefox 54 (_ 4_), чем другие решения. На моем компьютере работает 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 "банан - это фрукт, собранный после сбора урожая"
4 'bnn s rp frt hrvstd nr th rvr '
5' банан as a rapa fraat harvastad naar tha ravar '
6' bununu is u ripo frait hurvostod nour tho rivor '
7 false
8 false
9 «БАНАН - СОЗДАННЫЕ ФРУКТЫ, СОБИРАЕМЫЕ У РЕКИ»
10 «БАНАН - СОБИРАЕМЫЕ ФРУКТЫ ОТ голубца»

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

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

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

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

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

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

Сейчас существует готовое предложение по интеграции String.prototype.replaceAll в официальную спецификацию. В конце концов, разработчикам не придется придумывать собственные реализации для replaceAll - вместо этого современные движки Javascript будут поддерживать его изначально.

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

Он отправлен в последние версии Chrome, Firefox и Safari.

Вот детали реализации:

Согласно текущему консенсусу TC39, String.prototype.replaceAll ведет себя идентично String.prototype.replace во всех случаях, кроме следующих двух случаев:

1. Если searchValue является строкой, String.prototype.replace заменяет только одно вхождение searchValue, тогда как String.prototype.replaceAll заменяет все вхождения searchValue (как если бы использовалось .split(searchValue).join(replaceValue) или глобальное регулярное выражение с правильным экранированием).
2. Если searchValue - неглобальное регулярное выражение, String.prototype.replace заменяет одно совпадение, тогда как String.prototype.replaceAll вызывает исключение. Это сделано для того, чтобы избежать путаницы между отсутствием глобального флага (что подразумевает НЕ заменять все) и именем вызываемого метода (что настоятельно рекомендует заменить все).

Примечательно, что String.prototype.replaceAll ведет себя так же, как String.prototype.replace, если searchValue является глобальным регулярным выражением.

Вы можете увидеть соответствующий спецификации полифилл здесь.

В поддерживаемых средах следующий фрагмент кода будет регистрировать foo-bar-baz без выдачи ошибки:

const str = 'foo bar baz';
console.log(
  str.replaceAll(' ', '-')
);

Вот очень простое решение. Вы можете назначить новый метод объекту String

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

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

console.log(str) // -> Test  test test  test test test  test test

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

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

В ноябре 2019 года в JavaScript string.prototype.replaceAll() добавлена ​​новая функция.

В настоящее время он поддерживается только с babel.JS, но, возможно, в будущем он может быть реализован во всех браузерах. Дополнительную информацию см. здесь.

Это можно решить с помощью регулярных выражений и флага 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);
};

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

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

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

    return str;
};

Я просто хочу поделиться своим решением, основанным на некоторых функциональных возможностях последних версий 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)

Это должно сработать.

String.prototype.replaceAll = function (search, replacement) {
    var str1 = this.replace(search, replacement);
    var str2 = this;
    while(str1 != str2) {
        str2 = str1;
        str1 = str1.replace(search, replacement);
    }
    return str1;
}

Пример:

Console.log("Steve is the best character in Minecraft".replaceAll("Steve", "Alex"));

Лучшее решение, чтобы заменить любой символ, мы используем функции indexOf(), includes() и substring() для замены совпадающей строки на предоставленную строку в текущей строке.

• Функция String.indexOf() предназначена для поиска n ^th позиция индекса соответствия.
• Метод String.includes() определяет, строка может быть найдена в другой строке, возвращая, при необходимости, истину или ложь.
• Функция String.substring() предназначена для получения части строки (_8 _, _ 9_). Добавьте заменяющую строку между этими частями, чтобы сгенерировать окончательную строку возврата.

Следующая функция позволяет использовать любой символ.
где, как RegExp, будет не разрешать использование специальных символов, таких как **, а некоторые символы должны быть экранированы, например $.

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

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

Вы получите SyntaxError, если используете недопустимый шаблон регулярного выражения, например '**'.

• Функция String.replace() используется для заменить указанную строку заданной строкой.
• Функция String.match() предназначена для поиска сколько раз строка повторяется.
• Метод RegExp.prototype.test выполняет поиск для соответствия между регулярным выражением и указанной строкой. Возвращает истину или ложь.

String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
    }
    return retStr;
};

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

Примеры использования вышеуказанных функций:

var str = "yash yas $dfdas.**";
console.log('String: ', str);

// No need to escape any special character
console.log('Index matched replace: ', str.replaceMatch('as', '*', 2));
console.log('Index Matched replace: ', str.replaceMatch('y', '~', 1));
console.log('All Matched replace: ', str.replaceAllMatches({'as': '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**': '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX all matched replace: ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

Результат:

String:  yash yas $dfdas.**
Index Matched replace:  yash yas $dfd*.**
Index Matched replace:  yash ~as $dfdas.**

All Matched replace:  Y**h Y** -dfd**.**
All Matched replace:  yash yas %$%dfdas.>>

REGEX All Matched replace:  Y**h Y** -dfd**.**

Это решение сочетает в себе некоторые предыдущие ответы и несколько лучше соответствует предложенному стандартному решению от августа 2020 года. Это решение по-прежнему актуально для меня в сентябре 2020 года, поскольку String.replaceAll недоступен в node двоичном файле, который я использую.

RegExp.escape - это отдельная проблема, которую нужно решить, но здесь она важна, потому что официальное предлагаемое решение автоматически избегает ввода на основе string find. Этот String.replaceAll полифилл не обошелся бы без логики RegExp.escape.

Я добавил ответ, который не заполняется RegExp.Escape, если вы этого не хотите.

Если вы передадите RegExp find, вы ДОЛЖНЫ включить g в качестве флага. Этот полифилл не принесет вам приятной ошибки TypeError и доставит вам много неприятностей.

Если вам нужно точное соответствие стандартам для приложения, которое строго полагается на стандартную реализацию, я предлагаю использовать babel или какой-либо другой инструмент, чтобы каждый раз получать «правильный ответ» вместо SO dot com. Так у вас не будет никаких сюрпризов.

Код:

if (!Object.prototype.hasOwnProperty.call(RegExp, 'escape')) {
  RegExp.escape = function(string) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
    // https://github.com/benjamingr/RegExp.escape/issues/37
    return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
  };
}

if (!Object.prototype.hasOwnProperty.call(String, 'replaceAll')) {
  String.prototype.replaceAll = function(find, replace) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
    // If you pass a RegExp to 'find', you _MUST_ include 'g' as a flag.
    // TypeError: "replaceAll must be called with a global RegExp" not included, will silently cause significant errors. _MUST_ include 'g' as a flag for RegExp.
    // String parameters to 'find' do not require special handling.
    // Does not conform to "special replacement patterns" when "Specifying a string as a parameter" for replace
    // Does not conform to "Specifying a function as a parameter" for replace
    return this.replace(
          Object.prototype.toString.call(find) == '[object RegExp]' ?
            find :
            new RegExp(RegExp.escape(find), 'g'),
          replace
        );
  }
}

Код, уменьшенный:

Object.prototype.hasOwnProperty.call(RegExp,"escape")||(RegExp.escape=function(e){return e.replace(/[.*+\-?^${}()|[\]\\]/g,"\\$&")}),Object.prototype.hasOwnProperty.call(String,"replaceAll")||(String.prototype.replaceAll=function(e,t){return this.replace("[object RegExp]"==Object.prototype.toString.call(e)?e:new RegExp(RegExp.escape(e),"g"),t)});

Пример:

console.log(
  't*.STVAL'
    .replaceAll(
      new RegExp(RegExp.escape('T*.ST'), 'ig'),
      'TEST'
    )
);

console.log(
  't*.STVAL'
    .replaceAll(
      't*.ST',
      'TEST'
    );
);

Код без RegExp.Escape:

if (!Object.prototype.hasOwnProperty.call(String, 'replaceAll')) {
  String.prototype.replaceAll = function(find, replace) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
    // If you pass a RegExp to 'find', you _MUST_ include 'g' as a flag.
    // TypeError: "replaceAll must be called with a global RegExp" not included, will silently cause significant errors. _MUST_ include 'g' as a flag for RegExp.
    // String parameters to 'find' do not require special handling.
    // Does not conform to "special replacement patterns" when "Specifying a string as a parameter" for replace
    // Does not conform to "Specifying a function as a parameter" for replace
    return this.replace(
          Object.prototype.toString.call(find) == '[object RegExp]' ?
            find :
            new RegExp(find.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'), 'g'),
          replace
        );
  }
}

Код без RegExp.Escape, минимизированный:

Object.prototype.hasOwnProperty.call(String,"replaceAll")||(String.prototype.replaceAll=function(e,t){return this.replace("[object RegExp]"==Object.prototype.toString.call(e)?e:new RegExp(e.replace(/[.*+\-?^${}()|[\]\\]/g,"\\$&"),"g"),t)});

Используйте разделение и объединение

var str = "Test abc test test abc test test test abc test test abc";
var replaced_str = str.split('abc').join('');
console.log(replaced_str);

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

e.g.

replaceAll("nihIaohi", "hI", "hIcIaO", true)

Итак, вот правильный вариант replaceAll, включая строковый прототип:

function replaceAll(str, find, newToken, ignoreCase)
{
    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
}

Или, если вы хотите иметь функцию прототипа строки:

String.prototype.replaceAll = function (find, replace) {
    let str = this;

    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
};

Самое простое решение -

let str = "Test abc test test abc test test test abc test test abc";

str = str.split(" ");
str = str.filter((ele, key)=> ele!=="abc")
str = str.join(" ")

Или просто -

str = str.split(" ").filter((ele, key) => ele != "abc").join(" ")

В августе 2020 года

Больше никаких регулярных выражений

const str = "Test abc test test abc test test test abc test test abc";
const modifiedStr = str.replaceAll('abc', '');
console.log(modifiedStr);

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll

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

 const str = "Test abc test test abc test test test abc test test abc";
    
    const compare = "abc";
    arrayStr = str.split(" ");
    arrayStr.forEach((element, index) => {
      if (element == compare) {
        arrayStr.splice(index, 1);
      }
    });
    const newString = arrayStr.join(" ");
    console.log(newString);

Я знаю, что это не лучший способ сделать это, но вы можете попробовать следующее:

var annoyingString = "Test abc test test abc test test test abc test test abc";

while (annoyingString.includes("abc")) {
    annoyingString = annoyingString.replace("abc", "")
}

Мы можем использовать метод replace в JavaScript:

var result = yourString.replace('regexPattern', "replaceString");

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

var expectedString = str.replace(/abc(\s|$)/g, "");

console.log(expectedString);

Я добавил функцию ниже на эту тестовую страницу perf в разделе "библиотеки":

https://jsben.ch/LFfWA

function _replace(t, s, r){
    var i = t.indexOf(s);
    if (i == -1) return t;
    return t.slice(0, i) + r + _replace(t.slice(i + s.length, t.length), s,r);
}

..и введите это как тест:

var replaced = _replace(testString, 'abc','123');

.. и эта функция для меня выполняется примерно на 34% быстрее, чем split или regex. Идея / надежда заключалась в том, чтобы в конечном итоге вставить все меньшие и меньшие части строки в стек, а затем построить весь результат, развернув стек, тем самым минимизируя лишние копии строк и дополнительный поиск по одним и тем же строковым данным и, надеюсь, оптимизируя использование ЦП кеш.

Часть мысли заключалась в том, что если строка не слишком велика, она может оказаться в кэше ЦП; передача и вставка частей помещает эти биты в кеш, и затем поиск может работать полностью с использованием кэшированных данных ЦП. Теперь, независимо от того, происходит ли это на самом деле, я уверен, полностью зависит от реализации js.

Это не так быстро, насколько это возможно, но это настолько быстро, насколько я мог бы обойтись без изменяемых строк. Массивы в JavaScript, вероятно, имеют указатель для каждого элемента, поэтому решение, включающее множество элементов массива, вряд ли будет столь же дружественным к кеш-памяти ЦП, как это.

Начиная с v85, Chrome теперь изначально поддерживает String.prototype.replaceAll. Обратите внимание, что это превосходит все другие предлагаемые решения, и его следует использовать после получения основной поддержки.

Статус функции: https://chromestatus.com/feature/6040389083463680

var s = "hello hello world";
s = s.replaceAll("hello", ""); // s is now "world"
console.log(s)

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

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

var text = "heloo,hai,hei"

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

or

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

Из Заменить строку JavaScript с помощью метода replace () на регулярное выражение : JavaScript предоставляет прямой способ заменить часть строки другой строкой, и есть некоторые уловки, с помощью которых вы можете это сделать.

const str = "To do or not to do";
const pattern = /do/g;
const replaceBy = "Code";
console.log(str.replace(pattern, replaceBy));

const str = "To do or not to do";
const pattern = "do";
const replaceBy = "Code";
console.log(str.replaceAll(pattern, replaceBy));

const pattern2 = /do/g;
console.log(str.replaceAll(pattern2, replaceBy));

const str = "To do or not to do";
const newStr = str.split("do").join("Code");
console.log(newStr);