文字列のすべての出現を置き換える方法は？

私はこの文字列を持っています：

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

実行：

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

abc上記の文字列の最初の出現のみを削除するようです。

どうすればそれをすべて置き換えることができますか？

注：パフォーマンスが重要なコードではこれを使用しないでください。

単純なリテラル文字列の正規表現の代わりに、次を使用できます

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

一般的なパターンは

str.split(search).join(replacement)

以前はreplaceAll、正規表現を使用するよりも高速な場合がありましたが、最近のブラウザではそうではないようです。

ベンチマーク：https : //jsperf.com/replace-all-vs-split-join

結論：パフォーマンスが重要なユースケース（たとえば、数百の文字列の処理）がある場合は、Regexpメソッドを使用します。しかし、ほとんどの一般的な使用例では、これは特殊文字について心配する必要がないという価値があります。

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ガイドで説明されており、次のユーティリティ関数が示されています（この回答は最初に作成されてから少なくとも2回変更されているため、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);
}

完全を期すために、私はこれを行うためにどの方法を使用するべきかについて考えるようになりました。このページの他の回答で提案されているように、これを行うには基本的に2つの方法があります。

注：一般に、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入力の2倍の速さです。

これら2つの実装を相互に実行するこのベンチマークを確認してください。

下記の@ThomasLeducなどのコメントで述べたように、正規表現で特殊文字searchとして予約されている特定の文字が含まれている場合、正規表現ベースの実装で問題が発生する可能性があります。実装では、呼び出し元が事前に文字列をエスケープするか、正規表現（MDN）のテーブルに文字がない文字列のみを渡すことを想定しています。

MDNは文字列をエスケープするための実装も提供します。これもとして標準化されていればいいのですRegExp.escape(str)が、残念ながら存在しません。

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

実装escapeRegExp内で呼び出すこともできますString.prototype.replaceAllが、これがパフォーマンスにどの程度影響するかはわかりません（すべての英数字文字列のように、エスケープが不要な文字列でも可能性があります）。

gフラグを設定して正規表現を使用すると、すべてが置き換えられます。

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

こちらもご覧ください

受け入れられた回答に基づく文字列プロトタイプ関数は次のとおりです。

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find, 'g'), replace);
};

編集する

find特殊文字が含まれる場合は、エスケープする必要があります。

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

フィドル：http : //jsfiddle.net/cdbzL/

更新：

アップデートには少し遅れますが、私はこの質問に出くわしただけで、以前の答えが満足のいくものではないことに気づきました。質問は単一の単語を置き換えることを含むため、単語の境界を使用することを誰も考えなかったのは驚くべきことです（\b）

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

これは、ほとんどの場合、単語の一部の置き換えを回避する単純な正規表現です。ただし、ダッシュ-は単語の境界と見なされます。したがって、この場合は条件文を使用して、次のような文字列の置換を回避できますcool-cat。

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

基本的に、この質問はここの質問と同じです：Javascriptは「」を「」に置き換えます

@マイク、私がそこに与えた答えを確認してください... regexpは、subsrtingの複数のオカレンスを置換する唯一の方法ではありません。柔軟に考えて、分割して考えてください！

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、条件付きで「猫」のみを置き換える正規表現。（つまり、単語の一部ではない）、次のように：

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

私の推測では、これはあなたのニーズを満たしています。もちろん、それは完全なものではありませんが、開始するには十分なはずです。これらのページでさらに読むことをお勧めします。これは、特定のニーズを満たすためにこの表現を完成させるのに役立ちます。

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

http://www.regular-expressions.info

最終追加：

この質問はまだ多くのビューを取得しているので.replace、コールバック関数での使用例を追加すると思います。この場合、それが劇的に表現を簡素化し、正しい大文字小文字に置き換え、またはその両方を交換するように、さらに多くの柔軟性を提供catし、cats一度に：

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

グローバル正規表現と照合します。

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

1回限りの使用を置き換えるには：

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

複数回使用する場合：

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

これらは、最も一般的で読みやすい方法です。

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

方法1：

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

方法2：

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

方法3：

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

方法4：

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

出力：

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

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

または、ここからreplaceAll関数を試してください。

組み込みオブジェクトを拡張する便利なJavaScriptメソッドは何ですか？

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

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'

使用するRegExpにはJavaScriptを忘れないで、単にコードの下のような何かを、あなたのために仕事をすることができ/gためその傑出した後の世界：

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

再利用を考えている場合は、それを行う関数を作成しますが、これは1行の関数であるためお勧めできませんが、これを頻繁に使用する場合は、次のように書くことができます。

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

以下のようにコードで繰り返し使用します。

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

しかし、前に述べたように、書き込まれる行やパフォーマンスの点で大きな違いはありません。関数をキャッシュするだけで、長い文字列のパフォーマンスが向上し、再利用する場合はDRYコードの優れた方法になる場合があります。

すべての「abc」を「x」に置き換えたいとします。

let some_str = 'abc def def lom abc abc def'.split('abc').join('x')
console.log(some_str) //x def def lom x x def

文字列プロトタイプを変更するよりも簡単なことを考えていました。

正規表現を使用します。

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

一重引用符を置き換える：

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

    return text;
}

//出現回数が0になるまでループします。または、単にコピー/貼り付けします

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

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

上記の答えよりも私にとってはうまくいきました。したがって、テキスト（）のnew RegExp("abc", 'g')すべての出現（'g'フラグ）に一致するRegExpを作成します"abc"。2番目の部分は、空の文字列（""）に置き換えられます。 strは文字列であり、オーバーライドではreplace(...)なく結果を返すだけなので、オーバーライドする必要があります。場合によっては、それを使用することもできます。

これは、正規表現を使用しない最速のバージョンです。

jsperfの改訂

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

分割して結合する方法のほぼ2倍の速度です。

あなたの場合は、ここでコメントに尖っているように、これは動作しませんomit変数が含まれているplaceのように、： replaceAll("string", "s", "ss")、常に単語の別の発生を置き換えることができるようになりますので。

私の再帰的置換のバリアントを持つ別のjsperfがさらに速くなります（http://jsperf.com/replace-all-vs-split-join/12）！

• 2017年7月27日更新：最近リリースされたChrome 59の中で、RegExpのパフォーマンスが最も速いようです。

パフォーマンス

今日27.12.2019 選択したソリューションに対してmacOS v10.13.6（High Sierra）でテストを実行します。

結論

• str.replace(/abc/g, '');（Cは）すべての文字列のために良いクロスブラウザ高速なソリューションです。
• split-join（A、B）またはreplace（C、D）に基づくソリューションは高速です
• while（E、F、G、H）に基づくソリューションは遅い-小さな文字列では通常〜4倍遅く、長い​​文字列では約〜3000倍（！）遅い
• 反復解（RA、RB）は遅く、長い​​文字列では機能しません

自分のソリューションも作成します。それは現在、質問の仕事をする最も短いもののようです：

str.split`abc`.join``

str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);

詳細

テストはChrome 79.0、Safari 13.0.4およびFirefox 71.0（64ビット）で実行されました。テストRAとRB再帰の使用。結果

短い文字列-55文字

ここでマシン上でテストを実行できます。Chromeの結果：

長い文字列：275,000文字

RAとRBが与える再帰的解

RangeError：呼び出しスタックの最大サイズを超えました

100万人のキャラクターの場合、彼らはChromeを壊す

他のソリューションで100万文字のテストを実行しようとしていますが、E、F、G、Hに非常に時間がかかるため、ブラウザーがスクリプトを中断するように求められるため、テスト文字列を275K文字に縮小します。ここでマシン上でテストを実行できます。Chromeの結果

テストで使用されるコード

var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) => console.log(`${version}: ${result}`);


function A(str) {
  return str.split('abc').join('');
}

function B(str) {
  return str.split`abc`.join``; // my proposition
}


function C(str) {
  return str.replace(/abc/g, '');
}

function D(str) {
  return str.replace(new RegExp("abc", "g"), '');
}

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

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

function G(str) {
  while(str.includes("abc")) { str = str.replace('abc', ''); }
  return str;
}

// src: https://stackoverflow.com/a/56989553/860099
function H(str)
{
    let i = -1
    let find = 'abc';
    let newToken = '';

    if (!str)
    {
        if ((str == null) && (find == null)) return newToken;
        return str;
    }

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

// src: https://stackoverflow.com/a/22870785/860099
function RA(string, prevstring) {
  var omit = 'abc';
  var place = '';
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return RA(prevstring, string)
}

// src: https://stackoverflow.com/a/26107132/860099
function RB(str) {
  var find = 'abc';
  var replace = '';
  var i = str.indexOf(find);
  if (i > -1){
    str = str.replace(find, replace);
    i = i + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + RB(st2, find, replace);
    }
  }
  return str;
}




log('A ', A(t));
log('B ', B(t));
log('C ', C(t));
log('D ', D(t));
log('E ', E(t));
log('F ', F(t));
log('G ', G(t));
log('H ', H(t));
log('RA', RA(t)); // use reccurence
log('RB', RB(t)); // use reccurence

<p style="color:red">This snippet only presents codes used in tests. It not perform test itself!<p>

検索したいものがすでに文字列内にあり、正規表現のエスケープ機能が手元にない場合は、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;
}

私はこの方法が好きです（少しきれいに見えます）：

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

正規表現を使用せずにこれを行う最も簡単な方法は、次のコードのように分割して結合することです。

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

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

http://jsfiddle.net/ANHR9/

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

文字列にのような同様のパターンが含まれている場合、abcccこれを使用できます。

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

以前の答えはあまりにも複雑です。次のようなreplace関数を使用するだけです。

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

探している文字列が置換後も存在しないことを確認する場合は、ループを使用する必要があります。

例えば：

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

完了すると、「テストabc」が残ります。

これを解決する最も簡単なループは次のとおりです。

var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
   str.replace(/abc/g, '');
}

ただし、これにより、各サイクルで2回置換が実行されます。おそらく（投票される可能性があります）組み合わせると、少し効率がよくなりますが、読みにくい形式になります。

var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!

これは、重複する文字列を探すときに特に役立ちます。
たとえば、「a ,,, b」があり、重複するカンマをすべて削除したい場合などです。
[その場合、.replace（/、+ / g、 '、'）を実行できますが、ある時点で、正規表現は複雑になり、代わりにループするほど遅くなります。]

人々は正規表現の使用に言及しましたが、テキストの大文字小文字に関係なくテキストを置き換えたい場合は、より良いアプローチがあります。大文字または小文字のように。以下の構文を使用

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

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

ここで詳細な例を参照できます。

以下の方法を簡単に使用できます

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

追加するだけ /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 グローバルを意味します