javascript - remove - w3school string replace




如何在JavaScript中替換所有出現的字符串? (20)

我有這個字符串:

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

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

似乎只刪除了上面字符串中第一次出現的abc 。 如何更換所有出現的內容?


//循環直到數字出現為0.或者只是複制/粘貼

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

更新:

這是一個更新有點遲,但因為我偶然發現了這個問題,並註意到我以前的答案不是我很滿意的答案。 由於問題涉及替換單個單詞,所以沒有人想到使用單詞邊界( \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" ?? 

哎呀,這可能不是你想要的。 那是什麼? 恕我直言,一個只有條件地取代'貓'的正則表達式。 (即不是單詞的一部分),如下:

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的例子。 在這種情況下,它大大簡化了表達提供了更大的靈活性,例如替換正確的大小寫或一次性替換catcats

'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

以下功能對我有用:

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 abc test test abc".split("abc").join("")

希望能幫助到你!


使用正則表達式:

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

假設您要將所有'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

我試圖考慮比修改字符串原型更簡單的事情。


只需添加/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表示全局


只需遵循這個oneliner正則表達式添加區分大小寫,所以如果你做“ABC”,它將與“abc”的行為相同。

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

如果字符串包含類似abccc類似模式,則可以使用:

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

如果您嘗試確保即使在替換後您要查找的字符串也不存在,則需要使用循環。

例如:

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

完成後,你仍然會'測試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 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);
};

我喜歡這種方法(它看起來更乾淨):

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

替換單引號:

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

    return text;
}

為了完整起見,我開始考慮使用哪種方法來完成這項工作。 根據本頁其他答案的建議,基本上有兩種方法可以做到這一點。

注意:通常,建議不要在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輸入的兩倍。

看看這個benchmark運行這兩個實現。

正如@ThomasLeduc和其他人在下面的評論中所指出的,如果search包含在正則表達式中保留為特殊字符的某些字符,則基於正則表達式的實現可能存在問題。 該實現假定調用者將事先轉義字符串,或者只傳遞正則表達式 (MDN)中沒有表中字符的字符串。

MDN還提供了一種逃避字符串的實現。 如果它也被標準化為RegExp.escape(str)會很好,但唉,它不存在:

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

我們可以在String.prototype.replaceAll實現中調用escapeRegExp ,但是,我不確定這會對性能產生多大影響(甚至可能對於不需要轉義的字符串,例如所有字母數字字符串)。


這是一個基於接受的答案的字符串原型函數:

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/http://jsfiddle.net/cdbzL/


雖然人們已經提到了正則表達式的使用,但是如果你想要替換文本而不管文本的情況如何,那麼有更好的方法。 像大寫或小寫。 使用以下語法

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

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

您可以在here參考詳細示例。


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

http://jsfiddle.net/ANHR9/


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(...)只返回結果,但不是覆蓋。 在某些情況下,您可能想要使用它。


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






replace