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

avatar
Ali
17 июля 2009 в 17:53
3848152
79
4900

В моем коде JavaScript есть эта строка:

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

Действует:

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

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

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

Источник
reinierpost
2 августа 2019 в 12:58
13

Какого результата вы ожидаете при замене всех вхождений aba в ababa на ca? caba? abca? cca?

sideshowbarker
29 июня 2020 в 05:26
8

String.prototype.replaceAll() теперь является стандартной частью ECMAScript tc39.es/ecma262/#sec-string.prototype.replaceall, документировано на developer.mozilla.org/docs/Web/JavaScript/Reference/ … и поставляется в Safari 13.1, Firefox 77 и Chrome Dev / Canary и будет поставляться в Chrome 85. Из документов: «Если searchValue - это строка, заменяет все вхождения searchValue (как если бы использовалось .split(searchValue).join(replaceValue) или глобальное регулярное выражение с правильным экранированием). Если searchValue является неглобальным регулярным выражением, генерируется исключение »

sarea
29 июля 2020 в 06:17
10

Используйте регулярное выражение вместо строки, оно должно выглядеть как str.replace(/abc/g, '');, чтобы получить все совпадения.

Ответы (79)

avatar
Matthew Crumley
17 июля 2009 в 20:29
2188

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

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

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


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

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

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

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

Общий шаблон:

str.split(search).join(replacement)

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

Контрольный показатель: https://jsben.ch/TZYzj

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

Remirror
20 сентября 2020 в 12:57
43

Забавно, что им потребовалось более 20 лет, чтобы добавить функцию типа replaceAll.

Tomasz Smykowski
19 октября 2020 в 18:31
13

Я не рекомендую использовать replaceAll в настоящий момент (2020 г.). Он не поддерживается некоторыми браузерами, в которых были обновления в этом году caniuse.com/?search=replaceAll Это слишком рано

Abion47
25 февраля 2021 в 01:38
12

NodeJS поддерживает replaceAll в версиях 15.x.

avatar
MMMahdy-PAPION
26 декабря 2021 в 06:20
2

Конечно, в 2021 году правильный ответ:

String.prototype.replaceAll ()

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

Если вы не хотите иметь дело с , замените () + RegExp.

Но что, если браузер <2020?

В этом случае нам понадобится polyfill (Принуждение старых браузеров к поддержке новых функций) (я думаю, что потребуется несколько лет) <293591435149576> <3595> Я не смог найти в ответах полностью верного метода. Поэтому я предлагаю эту функцию, которая будет определена как полифилл.

Предлагаемые мной варианты для replaceAll полифилла:

replaceAll полифил (с ошибкой глобального флага) [Более принципиальная версия]
if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : function(){throw new TypeError('replaceAll called with a non-global RegExp argument')}() // If not throw an error
                    : new RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}
replaceAll полифил (с отсутствием обработки глобального флага) [Мое первое предпочтение] - Почему?
if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : new RegExp(search.source, /\/([a-z]*)$/.exec(search.toString())[1] + 'g') // If not, make a global clone from the RegEx
                    : new RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}
Минимизированный [Мое первое предпочтение]:
if(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:new RegExp(search.source,/\/([a-z]*)$/.exec(search.toString())[1]+'g'):new RegExp(String(search).replace(/[.^$*+?()[{|\\]/g,"\\$&"),"g"),replace)}})}
Попробуйте:

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

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

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

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

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

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

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

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


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

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

// Browsers < 2020:
// xyz     xyz
// Browsers > 2020
// TypeError: String.prototype.replaceAll called with a non-global RegExp
Поддержка браузера:

IE 9+ (проверено в IE11)
Все остальные браузеры (после 2012 г.)

Результат такой же, как у собственного replaceAll в случае ввода первого аргумента:
null, undefined, Object, <1435914359536>, <1435914359536> .. ., RegExp, Number, String, ...

Ссылка: https://tc39.es/ecma262/#sec-string.prototype.replaceall

Важное примечание: Как отмечают некоторые профессионалы, многие из рекурсивных функций, предложенных в ответах, будут возвращать неправильный результат. (Попробуйте их с помощью случая Challenged из приведенного выше фрагмента)
Возможно, некоторые хитрые методы, такие как .split('searchValue').join('replaceValue') или некоторые хорошо управляемые функции, дают тот же результат, но определенно гораздо более низкую производительность, чем native replaceAll() / polyfill replaceAll() / replace() + RegExp


Другие методы назначения полифилов

Наивный, но поддерживает даже пожилых людей (лучше избегать)

Например, мы можем поддерживать IE7 +, не используя Object.defineProperty () и используя мой старый наивный метод присваивания:

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

И он должен хорошо работать для базового использования в IE7 +.
Но , как здесь объяснил @ sebastian-simon, это может вызвать вторичные проблемы в случае более продвинутого использования. Например:

for (var k in 'hi') console.log(k);
// 0
// 1
// replaceAll  <-- ?
Полностью надежный, но тяжелый

На самом деле, предложенный мной вариант немного оптимистичен. Как мы полагаем, среда (Браузер / Узел) определенно рассчитана примерно на 2012-2021 годы, она также является стандартной / известной, поэтому не требует особого рассмотрения.
Но могут быть даже старые браузеры ИЛИ некоторые неожиданные проблемы, а полифиллы по-прежнему могут поддерживать и решать больше возможных проблем среды. Поэтому, если нам нужна максимально возможная поддержка, мы можем использовать polyfill libraries, например:

https://polyfill.io/

Специально для replaceAll :

<script src="https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll"></script>
avatar
Alecx
8 декабря 2021 в 21:24
0

Я прочитал этот вопрос и ответы, но не нашел для себя подходящего решения. Хотя эта ветка весьма полезна, я решил создать собственное решение с нуля. Проблемы при такой замене:

  • Часто бывает недостаточно просто найти строку, которая соответствует любому верхнему / нижнему регистру. Например. для результатов поиска мне нужно заменить его тем же корпусом .
  • Если я имею дело с innerHTML, я могу легко повредить HTML-теги (например, появление hr в атрибуте href ).
  • Метод replaceAll () слишком нов для многих случаев использования и не решает всех проблем.

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

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

/* Iterate over table data cells to insert a highlight tag */
function highlightSearchResults(textFilter) {
  textFilter = textFilter.toLowerCase().replace('<', '&lt;').replace('>', '&gt;');
  let tds;
  tb = document.getElementById('sometable'); //root element where to search
  if (tb) {
    tds = tb.getElementsByTagName("td"); //sub-elements where to make replacements
  }
  if (textFilter && tds) {
    for (td of tds) {
      //specify your span class or whatever you need before and after
      td.innerHTML = insertCaseInsensitive(td.innerHTML, textFilter, '<span class="highlight">', '</span>');
    }
  }
}

/* Insert a highlight tag */
function insertCaseInsensitive(srcStr, lowerCaseFilter, before, after) {
  let lowStr = srcStr.toLowerCase();
  let flen = lowerCaseFilter.length;
  let i = -1;
  while ((i = lowStr.indexOf(lowerCaseFilter, i + 1)) != -1) {
    if (insideTag(i, srcStr)) continue;
    srcStr = srcStr.slice(0, i) + before + srcStr.slice(i, i+flen) + after + srcStr.slice(i+flen);
    lowStr = srcStr.toLowerCase();
    i += before.length + after.length;
  }
  return srcStr;
}

/* Check if an ocurrence is inside any tag by index */
function insideTag(si, s) {
  let ahead = false;
  let back = false;
  for (let i = si; i < s.length; i++) {
    if (s[i] == "<") {
      break;
    }
    if (s[i] == ">") {
      ahead = true;
      break;
    }
  }
  for (let i = si; i >= 0; i--) {
    if (s[i] == ">") {
      break;
    }
    if (s[i] == "<") {
      back = true;
      break;
    }
  }
  return (ahead && back);
}
Sebastian Simon
9 декабря 2021 в 11:52
0

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

Alecx
9 декабря 2021 в 19:58
0

О, эти ответы больше относятся к выделению! Однако я нашел только этот поток, связанный с заменой, в поисках некоторых решений для замены. Теперь я попробовал эти функции: если я правильно вижу, они не выделяют без учета регистра, я имею в виду: если найдены фразы «Текст» или «ТЕКСТ» (или даже «Текст», «tExT» и т. Д.) , они должны быть выделены как есть, без преобразования в нижний / верхний регистр. Фрагменты кода хороши тем, что они работают со всем документом, и готовыми к использованию решениями. Эти мои функции должны быть адаптированы под свои нужды, и я думаю, что это достаточно просто.

avatar
Ran Turner
16 октября 2021 в 15:03
7

String.prototype.replaceAll - ECMAScript 2021

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

const message = 'dog barks meow meow';
const messageFormatted = message.replaceAll('meow', 'woof')

console.log(messageFormatted);
Sebastian Simon
16 октября 2021 в 15:19
0

replaceAll уже предлагался почти в 20 других ответах и ​​комментариях, включая принятый ответ и ответ, получивший наибольшее количество голосов. Что это добавляет?

avatar
pedro casas
29 сентября 2021 в 09:48
0

повторяйте, пока не замените их все

const regex = /^>.*/im;
while (regex.test(cadena)) {
   cadena = cadena.replace(regex, '*');
}   
Sebastian Simon
29 сентября 2021 в 10:17
0

Этот подход заменит вхождения, которые появляются только после замены. Например. при замене всех вхождений "bc" на "b", тогда с учетом входной строки "abcc" должна получиться выходная "abc", но ваш подход даст "ab".

pedro casas
30 сентября 2021 в 11:15
0

Этот простой скрипт, как говорит Себастьян, также удаляет результаты, соответствующие выражению. В этом есть свои плюсы и минусы. Плохие новости он уже сообщил. Хорошей новостью является то, что он очень полезен для удаления тегов JS при атаках XSS и JavaScript Inject.

avatar
Oliver M Grech
30 августа 2021 в 10:16
7

После нескольких попыток и множества неудач я обнаружил, что приведенная ниже функция кажется наиболее универсальной, когда дело касается совместимости с браузером и простоты использования. Это единственное рабочее решение для старых браузеров, которое я нашел. (Да, хотя старые браузеры не рекомендуются и устарели, некоторые устаревшие приложения по-прежнему активно используют браузеры OLE (например, старые приложения VB6 или макросы Excel xlsm с формами)

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

function replaceAll(str, match, replacement){
   return str.split(match).join(replacement);
}
Sebastian Simon
30 августа 2021 в 10:27
0

Это уже предлагалось или упоминалось в 18 других ответах и ​​в комментариях под вопросом. Рекомендации по совместимости легко найти в CanIUse и MDN. Все это упоминается в принятом ответе.

Oliver M Grech
30 августа 2021 в 12:42
0

ну, на первый взгляд, я не нашел ничего, что упоминало бы старые браузеры и реализации OLE в устаревшем коде. Просто подумал, что это может помочь кому-то, нет смысла отрицать полезный ответ. Вы также не должны голосовать «за», я просто забочусь о том, чтобы кто-то нашел это полезным. Тем не менее, спасибо за ваш вклад

avatar
francis
25 июля 2021 в 12:49
0

С регулярным выражением i флаг для без учета регистра <280610803>

console.log('App started'.replace(/a/g, '')) // App strted
console.log('App started'.replace(/a/gi, '')) // pp strted

avatar
Force Bolt
7 июня 2021 в 14:17
0
// Try this way

const str = "Test abc test test abc test test test abc test test abc";
const result = str.split('abc').join('');
console.log(result);
avatar
Satish Chandra Gupta
19 апреля 2021 в 10:55
0

From JavaScript String Replace Using replace () Method With regex : JavaScript предоставляет прямой способ заменить часть строки другой строкой, а также есть некоторые уловки, с помощью которых ты можешь это сделать.

Чтобы заменить все вхождения, вы можете использовать метод replace() или replaceAll в JavaScript.

  1. replace() method - Чтобы заменить все элементы с помощью этого метода, используйте регулярное выражение в качестве шаблона, чтобы найти соответствующую строку, а затем замените ее новой строкой. Пожалуйста, подумайте об использовании с ним флага /g.

const str = "To do or not to do";
const pattern = /do/g;
const replaceBy = "Code";
console.log(str.replace(pattern, replaceBy));
  1. replaceAll() method - Чтобы заменить все элементы с помощью этого метода, используйте строку или регулярное выражение в качестве шаблона, чтобы найти соответствующую строку, а затем замените ее новой строкой. Мы должны использовать флаг /g с регулярным выражением в методе replaceAll .

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);
avatar
Chungmin Park
20 февраля 2021 в 10:29
0

Есть способ использовать новый метод replaceAll().

Но вам необходимо использовать современный браузер или среду выполнения JavaScript.

Вы можете проверить совместимость браузера в здесь.

avatar
Drewry Pope
7 сентября 2020 в 12:55
2

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

Drewry Pope
13 сентября 2020 в 09:47
0

RegExp.Escape был основан на моем ответе, связанном здесь: coderhelper.com/a/63838890/5979634

avatar
Nisharg Shah
25 августа 2020 в 21:19
1

В августе 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

raven
12 марта 2021 в 10:53
0

Uncaught TypeError: str.replaceAll is not a function",

Nisharg Shah
13 марта 2021 в 03:28
0

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

avatar
Mohit Yadav
25 августа 2020 в 05:55
-1

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

String.prototype.replaceAll = function(fromReplace, toReplace, {ignoreCasing} = {}) { return this.replace(new RegExp(fromReplace, ignoreCasing ? 'ig': 'g'), toReplace);}

и его можно использовать как

'stringwithpattern'.replaceAll('pattern','new-pattern')
Khalid Khan
25 августа 2020 в 09:29
0

Не могли бы вы уточнить, что делает приведенный выше код? Старайтесь давать правильные ответы, а не одинарные строчки.

Mohit Yadav
25 августа 2020 в 11:30
0

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

Jake Coxon
25 августа 2020 в 21:12
0

Это не работает, {ignoreCasing} пытается деструктурировать undefined в вашем примере. И this не ссылается на строку при использовании функции стрелки

Mohit Yadav
26 августа 2020 в 06:09
1

@JakeCoxon, да, мой плохой, обновил ответ, чтобы исправить проблемы: D ура!

avatar
Asakkour Soufiane
7 июля 2020 в 17:21
2

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

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);
avatar
Iftikhar Hussain
22 июня 2020 в 06:30
4

Вот очень простое решение. Вы можете назначить новый метод объекту 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
Moritz
28 июля 2020 в 15:16
0

Присвоение прототипу глобального объекта называется пополнением прототипов и считается довольно плохим анти-шаблоном. Это приемлемо только для полифиллов, которые реализуют указанное поведение функции для старых движков, которые его еще не поддерживают. Эта реализация имеет семантику, отличную от спецификации. Рассмотрим 'hi'.replaceAll ('. ',' X ') // =>' xx '

Iftikhar Hussain
29 июля 2020 в 16:38
0

Спасибо, Мориц, я думаю, что расширение или модификация прототипов любых объектов, особенно нативных, считается плохой практикой, но не добавлять новый метод Если у вас есть какой-либо источник, поделитесь

Moritz
30 июля 2020 в 17:24
1

Мне кажется, что расширение и «добавление новых методов» - одно и то же. Это проблема, потому что теперь в спецификации фактически есть метод replaceAll, который имеет другую семантику, которая может нарушить код даже во внешних зависимостях. См .: flaviocopes.com/javascript-why-not-modify-object-prototype

avatar
Matěj Štágl
9 июня 2020 в 10:39
0

Начиная с версии 85, 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)
avatar
Shavais
24 мая 2020 в 01:35
0

Я добавил функцию ниже на эту тестовую страницу 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% быстрее, чем разделение или регулярное выражение. Идея / надежда заключалась в том, чтобы в конечном итоге вставить все меньшие и меньшие части строки в стек, а затем построить весь результат путем разворачивания стека, тем самым минимизируя лишние копии строк и дополнительный поиск по одним и тем же строковым данным и, надеюсь, оптимизируя использование ЦП. кеш.

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

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

avatar
e102
1 марта 2020 в 16:54
0

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

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

while (annoyingString.includes("abc")) {
    annoyingString = annoyingString.replace("abc", "")
}
avatar
Lova Chittumuri
6 февраля 2020 в 07:22
0

Мы можем использовать метод 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);
avatar
Kamil Kiełczewski
27 декабря 2019 в 16:03
30

Производительность

Сегодня, 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 используется рекурсия. Результаты

Enter image description here

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

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

Enter image description here

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

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

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

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

enter image description here

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

enter image description here

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

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://coderhelper.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://coderhelper.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://coderhelper.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>
Márk Gergely Dolinka
31 декабря 2019 в 12:59
2

Это чертовски подробный ответ! Большое спасибо! Хотя мне любопытно, почему синтаксис «new RegExp (...)» дает такое значительное улучшение.

avatar
Alien
12 декабря 2019 в 17:34
3

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

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

Ali
13 декабря 2019 в 15:59
5

Вау, javascript наконец-то добавляет то, что было в Java 1.0 в 1995 году. Отлично!

avatar
Ws Memon
22 ноября 2019 в 11:19
-1

Проверьте это. Я уверен, что это вам поможет:

<!DOCTYPE html>
<html>
<body>
<p>Click the button to do a global search and replace for "is" in a string.</p>
<button onclick="myFunction()">Try it</button>
<p id="demo"></p>
<script>
function myFunction() {
  var str = 'Is this "3" dris "3"?';
  var allvar= '"3"';
  var patt1 = new RegExp( allvar, 'g' );
  document.getElementById("demo").innerHTML = str.replace(patt1,'"5"');
}
</script>
</body>
</html>

Вот ссылка JSFiddle.

avatar
Thomas Orlita
11 ноября 2019 в 07:25
12

По состоянию на август 2020 года существует предложение этапа 4 в ECMAScript, которое добавляет метод replaceAll в String. <5494599>.

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

Использование такое же, как и в методе replace:

String.prototype.replaceAll(searchValue, replaceValue)

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

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

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

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

pcworld
3 июня 2020 в 00:31
0

Согласно MDN, это было доступно с Firefox 77 и Chromium 85.

avatar
CertainPerformance
18 октября 2019 в 02:48
4

Теперь есть готовое предложение для интеграции 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 или searchValue было использовано глобальное регулярное выражение с правильным экранированием).
  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(' ', '-')
);
avatar
Rakib Uddin
4 октября 2019 в 15:14
3
str = "Test abc test test abc test test test abc test test abc"

str.split(' ').join().replace(/abc/g,'').replace(/,/g, ' ')
avatar
Stefan Steiger
11 июля 2019 в 12:45
1

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

например

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;
};
avatar
Raghavendra S
30 мая 2019 в 04:43
7

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

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 "
avatar
Indrajeet Singh
29 мая 2019 в 11:11
67

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

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

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

var res = str.replace(/abc/g, "");
avatar
Nouman Dilshad
20 мая 2019 в 09:18
0

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

 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);
avatar
sajadre
14 мая 2019 в 18:42
14

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

var str = "Test abc test test abc test test test abc test test abc";
console.log(str.split('abc').join(''));
avatar
Jessie Lesbian
9 мая 2019 в 05:11
2

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

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"));
Peter Mortensen
8 марта 2020 в 18:26
0

@aabbccsmith: Каким образом? Вы можете уточнить?

alistair
9 марта 2020 в 13:13
0

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

Luiz Felipe
6 мая 2020 в 16:49
0

«циклы на таких строках не должны одобряться» было бы хорошо, если бы этот язык программирования не был таким дрянным

avatar
VhsPiceros
16 апреля 2019 в 00:37
6

Я использую разделение и соединение или эту функцию

function replaceAll( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}
avatar
Adnan Toky
25 марта 2019 в 09:38
65

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

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
avatar
Rinold
26 февраля 2019 в 17:36
1
 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
avatar
prime
15 февраля 2019 в 19:15
6

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

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?]
avatar
Brijesh Kumar Kushwaha
9 февраля 2019 в 08:28
1

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

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(" ")
avatar
Yash
7 февраля 2019 в 13:49
2

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

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

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

David Mårtensson
20 мая 2020 в 10:12
0

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

avatar
Ashish
29 января 2019 в 05:05
6

Метод 1

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

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

Метод 2

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

«Тест abc test test abc test test test abc test test abc» .split («abc»). Join («»)

avatar
Arian Saputra
22 января 2019 в 12:33
0

Вы можете попробовать следующее:

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

var text = "heloo,hai,hei"

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

или

text.forEach((value) => {
  hasil = hasil.replace(',', '')
})
avatar
Black
23 октября 2018 в 09:34
12

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

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);
avatar
Ferie
4 сентября 2018 в 16:24
5

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

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

avatar
mostafa elmadany
27 апреля 2018 в 08:49
13

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

str.replace(/abc(\s|$)/g, "")
avatar
TheAivis
11 апреля 2018 в 12:16
3

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

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);
rak007
20 апреля 2018 в 13:19
0

Ваш код не работает, если слова имеют одинаковые буквы. Пример: var test = "Groups_4_Questions_0__Options_0_Wording" .replaceAll ([4, 0, 0], [100, 200, 300])

TheAivis
20 апреля 2018 в 13:52
0

Не предназначено для этого. Только для уникальных заменяемых значений.

rak007
20 апреля 2018 в 13:53
1

это бесполезно тогда в большинстве случаев

avatar
Andrés
26 января 2018 в 23:05
2

Я просто хочу поделиться своим решением, основанным на некоторых функциональных возможностях последних версий 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)
avatar
csomakk
28 декабря 2017 в 12:27
27
str = str.replace(new RegExp("abc", 'g'), "");

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

avatar
KARTHIKEYAN.A
28 декабря 2017 в 09:44
3

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

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')
avatar
Paulo Buchsbaum
16 августа 2017 в 20:57
5

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

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

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

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

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

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

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

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

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

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

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

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

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

      // found the character or string key in the target

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

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

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

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

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

 Parameters    
 ==========    

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

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

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


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

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

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

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

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

Честно говоря, я провел тест , без параметров.

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

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

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

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

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

Bart Read
4 сентября 2017 в 06:53
0

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

Paulo Buchsbaum
5 сентября 2017 в 18:34
1

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

avatar
Alireza
6 июня 2017 в 13:39
43

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

avatar
User
17 марта 2017 в 04:58
5

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

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

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

http://www.google.com/a%20file%20with%20spaces.html
avatar
C. Morgan
15 октября 2016 в 16:54
2

Эту проблему можно решить с помощью регулярных выражений и флага 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);
};
avatar
Emilio Grisolía
10 сентября 2016 в 14:59
41

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

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

avatar
Cheezy Code
3 мая 2016 в 18:39
10

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

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

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

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

alikuli
3 августа 2016 в 10:15
0

с сайта примера: "/ toBeReplacedString / gi - это регулярное выражение, которое вам нужно использовать. Здесь g представляет глобальное соответствие, а i представляет нечувствительность к регистру. По умолчанию регулярное выражение чувствительно к регистру"

avatar
theWalker
11 апреля 2016 в 18:01
4
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
Jonathan ANTOINE
24 июня 2016 в 08:44
3

если замена содержит "найти", у вас будет бесконечный цикл

avatar
Nivesh Saharan
4 марта 2016 в 08:11
4

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

String.prototype.replaceAll = function(find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"), 'g'), replace);
};
avatar
Sandeep Gantait
16 февраля 2016 в 09:53
7

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

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

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

avatar
tk_
15 февраля 2016 в 12:05
7

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

/**
 * Replace all the occerencess of $find by $replace in $originalString
 * @param  {originalString} input - Raw string.
 * @param  {find} input - Target key word or regex that need to be replaced.
 * @param  {replace} input - Replacement key word
 * @return {String}       Output string
 */
function replaceAll(originalString, find, replace) {
  return originalString.replace(new RegExp(find, 'g'), replace);
};
avatar
Termininja
12 января 2016 в 23:43
6

Я использую 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'
avatar
Chris Rosete
19 июня 2015 в 21:24
32

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

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

    return text;
}
avatar
Reza Fahmi
5 июня 2015 в 07:16
8

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

avatar
Tim Rivoli
29 сентября 2014 в 19:12
19
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;
}
avatar
SamGoody
28 сентября 2014 в 19:58
10

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

Например:

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

avatar
Guy
14 сентября 2014 в 18:12
4

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

// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;
avatar
zdennis
29 апреля 2014 в 10:25
14
while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}
avatar
Cole Lawrence
4 апреля 2014 в 18:49
26

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

Пересмотренный 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.
avatar
Antonio Mirarchi
7 января 2014 в 19:11
2

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

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

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

    return str;
};
Jonathan ANTOINE
24 июня 2016 в 08:43
4

если замена содержит "найти", у вас будет бесконечный цикл

avatar
SiwachGaurav
24 декабря 2013 в 11:05
6

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

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);
 };
avatar
pkdkk
4 сентября 2013 в 10:01
14
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

avatar
Cory Gross
12 июля 2013 в 01:46
2469

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

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

avatar
rakslice
19 июня 2013 в 23:21
22

Если то, что вы хотите найти, уже находится в строке, и у вас нет удобного средства защиты с регулярным выражением, вы можете использовать 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'));
avatar
Raseela
5 июня 2013 в 04:57
26

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

function replaceAll(find, replace, str) {
    while (str.indexOf(find) > -1) {
        str = str.replace(find, replace);
    }
    return str;
}
Rob W
29 октября 2013 в 11:33
24

Этот метод опасен, не используйте его. Если строка замены содержит ключевое слово поиска, возникнет бесконечный цикл. По крайней мере, сохраните результат .indexOf в переменной и используйте эту переменную в качестве второго параметра .indexOf (минус длина ключевого слова плюс длина строки замены).

avatar
Owen
15 мая 2013 в 14:03
16

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

text = text.replace(new RegExp("cat","g"), "dog"); 
avatar
jesal
11 февраля 2013 в 23:03
122

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

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/

avatar
Elias Van Ootegem
1 марта 2012 в 10:02
91

Обновить :

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

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

Это простое регулярное выражение, которое в большинстве случаев позволяет избежать замены частей слов. Однако тире - по-прежнему считается границей слова. Таким образом, в этом случае можно использовать условные выражения, чтобы избежать замены строк типа cool-cat:

'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"

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

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

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

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

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

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

var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ?? 

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

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

Думаю, это соответствует вашим потребностям. Конечно, это не полное доказательство, но этого должно быть достаточно, чтобы вы начали. Я бы рекомендовал прочитать еще на этих страницах. Это окажется полезным для усовершенствования этого выражения в соответствии с вашими конкретными потребностями.

http://www.javascriptkit.com/jsref/regexp.shtml

http://www.regular-expressions.info


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

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

'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
   .replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
    {
       //check 1st, capitalize if required
       var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
       if (char1 === ' ' && char2 === 's')
       {//replace plurals, too
           cat = replacement + 's';
       }
       else
       {//do not replace if dashes are matched
           cat = char1 === '-' || char2 === '-' ? cat : replacement;
       }
       return char1 + cat + char2;//return replacement string
    });
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar
avatar
Vitim.us
28 октября 2011 в 02:36
6

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

function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}
Bryan
16 апреля 2013 в 13:58
1

Это неверно. replaceAll("123434", "1234", "12") должен возвращать "1234", но вместо этого возвращает "12".

Vitim.us
16 апреля 2013 в 16:16
2

это зависит от того, разрешаете ли вы заменять «рекурсивно» или нет.

user1002973
16 мая 2013 в 14:44
9

replaceAll («abc», «a», «ab») никогда не завершается

avatar
Donnie DeBoer
17 июля 2009 в 17:56
40

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

str.replace(/abc/g, '');
avatar
SolutionYogi
17 июля 2009 в 17:55
51
str = str.replace(/abc/g, '');

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

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

или:

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

РЕДАКТИРОВАТЬ: Пояснение по поводу replaceAll доступности

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

Пример:

var output = "test this".replaceAll('this', 'that'); // output is 'test that'.
output = output.replaceAll('that', 'this'); // output is 'test this'
avatar
Sean Bright
17 июля 2009 в 17:54
4734

По состоянию на август 2020 года: Современные браузеры поддерживают для String.replaceAll() метода, определенного спецификацией языка 801701901.


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

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

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

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

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

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

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

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

avatar
scronide
6 мая 2009 в 23:23
75

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

anotherString = someString.replace(/cat/g, 'dog');
avatar
Adam A
6 мая 2009 в 23:18
745

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

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

См. Также здесь