it-swarm.com.ru

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

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

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

Дела

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

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

3564
Click Upvote

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

Примечание: В общем случае расширение встроенных прототипов в 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 реализация на основе регулярных выражений - самая быстрая , а реализация split и join выполняется на 53% медленнее . Это означает, что регулярные выражения в два раза быстрее для ввода lorem ipsum, который я использовал.

Проверьте это benchmark запуск этих двух реализаций друг против друга.


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

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

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

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

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

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

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

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

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

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

Примечание: Регулярные выражения содержат специальные (мета) символы, и поэтому опасно слепо передавать аргумент в функции find выше без предварительной обработки для экранирования этих символов. Это описано в Mozilla Developer Network 's Руководство по регулярным выражениям 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);
}
3844
Sean Bright

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

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

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

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

str.split(search).join(replacement)

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

1244
Matthew Crumley

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

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

Смотрите здесь также

553
Adam A

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

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/

93
jesal

Обновление:

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

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

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

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

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

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

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

Ой, действительно, это, вероятно, не то, что вы хотите. Что же тогда? ИМХО, регулярное выражение, которое заменяет только «условно». (т.е. не является частью слова), например, так:

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
76
Elias Van Ootegem

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

anotherString = someString.replace(/cat/g, 'dog');
57
scronide
str = str.replace(/abc/g, '');

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

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

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

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

РЕДАКТИРОВАТЬ: Разъяснение о заменеВсе наличие

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

Например.

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

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

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

34
Emilio Grisolía

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

str.replace(/abc/g, '');
32
Donnie DeBoer

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

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

    return text;
}
30
Chris Rosete

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

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

Метод-01:

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

Метод-02:

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

Метод-03:

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

Метод-04:

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
29
Adnan Toky

// цикл до тех пор, пока число вхождений не достигнет 0. OR просто скопируйте/вставьте

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

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

Пересмотренный 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"), потому что она всегда сможет заменить другое вхождение Word.

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

  • Обновление от 27 июля 2017 года. Похоже, что RegExp теперь имеет самую быструю производительность в недавно выпущенном Chrome 59.
22
Cole Lawrence
str = str.replace(new RegExp("abc", 'g'), "");

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

22
csomakk

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

21
Alireza

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

18
rakslice
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;
}
16
Tim Rivoli

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

text = text.replace(new RegExp("cat","g"), "dog"); 
14
Owen
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

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

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

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

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

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

11
Black

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

Например:

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

9
SamGoody

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

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

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

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

9
Cheezy Code

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

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.

7
Sandeep Gantait

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

/**
 * Replace all the occerencess of $find by $replace in $originalString
 * @param  {originalString} input - Raw string.
 * @param  {find} input - Target key Word or regex that need to be replaced.
 * @param  {replace} input - Replacement key Word
 * @return {String}       Output string
 */
function replaceAll(originalString, find, replace) {
  return originalString.replace(new RegExp(find, 'g'), replace);
};
7
tk_

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

7
Reza Fahmi

Я решил эту проблему с помощью простой строки кода.

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

Проверьте пример на jsfiddle https://jsfiddle.net/pot6whnx/1/

7
Riajul Islam

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

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

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

получить:

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

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

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

4
Ferie

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

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

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

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

В моих приложениях я использую пользовательскую функцию, которая является самой мощной для этой цели, и даже оборачивая решение 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.  

Если честно, я запустил benchmark без проверки параметров. 

Вот мой тестовый набор с использованием 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 'банан как рапа фраат харвастад наар та равар'
6 «Бунун - это рип фрай хурвостод нур твой ривор»
7 ложных
8 ложных
9 'BANANA IS Зрелый фрукт, собранный недалеко от реки'
10 'BANANA IS Наркотик, собранный для любовника " 

3
Paulo Buchsbaum

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

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?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

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

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

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

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

2
TheAivis

Метод 1

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

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

Метод 2

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

"Тест abc тест, тест abc тест, тест, тест abc, тест, тест abc" .split ("abc"). Join ("")

2
ashish

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

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

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

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

2
KARTHIKEYAN.A

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

Я использую split и join или эту функцию

function replaceAll( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}
1
VhsPiceros

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

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

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

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

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

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

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"));
1
jessie tessie

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

var str="Test abc test test abc test test test abc test test abc";
str.split('abc').join('')
1
sajadre

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

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 "
0
Raghavendra S

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

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

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

    return str;
};
0
Antonio Mirarchi
 var myName = 'r//i//n//o//l////d';
  var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
  console.log(myValidName);

var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); > // jackdog
0
Rinold

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

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);
0
Nouman Dilshad

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

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

Or Simply - 

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

0
Brijesh Kumar

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

  • String.indexOf() функция для поиска nго соответствует позиции индекса.
  • String.includes() method определяет, может ли одна строка быть найдена в другой строке, возвращая true или false в зависимости от ситуации.
  • String.substring() функция предназначена для получения частей String (preceding, exceding). Добавлена ​​замещающая строка между этими частями для генерации окончательной возвращаемой строки.

Следующая функция позволяет использовать любой символ.
где as 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**.**

0
Yash