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




парсинг строки js (24)

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

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

дела

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

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


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

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

См. Также


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

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


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

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/


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

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.


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

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

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


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

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

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

Здесь вы можете привести подробный пример.


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

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

Обновить:

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

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

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

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

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

    return text;
}

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

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

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

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

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

Если то, что вы хотите найти, уже находится в строке, и у вас нет регулярного выражения escaper, вы можете использовать join / split:

    function replaceMulti(haystack, needle, replacement)
    {
        return haystack.split(needle).join(replacement);
    }

    someString = 'the cat looks like a cat';
    console.log(replaceMulti(someString, 'cat', 'dog'));


function replaceAll(str, find, replace) {
  var i = str.indexOf(find);
  if (i > -1){
    str = str.replace(find, replace); 
    i = i + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + replaceAll(st2, find, replace);
    }       
  }
  return str;
}

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например

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

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

Например:

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





replace