webdevqa.jp.net

JavaScriptで文字列のすべての出現箇所を置き換える方法

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

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

やる

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

上記の文字列で最初に見つかったabcのみを削除するようです。どうやって all の出現箇所を置き換えることができますか?

3564
Click Upvote

完全を期すために、私はこれを実行するためにどの方法を使用すべきかについて考えるようになりました。このページの他の回答で示唆されているように、これを行うには基本的に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イプサム入力の2倍の速さです。

これら2つの実装を互いに対比して実行している benchmark を調べてください。


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

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

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

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

2009
Cory Gross
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ガイド でカバーされています。

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

したがって、上記のreplaceAll()関数をより安全にするために、escapeRegExpも含めると、次のように変更できます。

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

注:これを実際のコードで使用しないでください。

単純なリテラル文字列の正規表現に代わるものとして、次のようにします。

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

一般的なパターンは

str.split(search).join(replacement)

これは場合によってはreplaceAllと正規表現を使用するよりも速いことがありましたが、最近のブラウザではそうではありません。したがって、これは実際のコードではなく、正規表現をエスケープする必要性を回避するためのクイックハックとして実際に使用されるべきです。

1244
Matthew Crumley

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

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

こちらも見てください

553
Adam A

これは、受け入れられた答えに基づく文字列プロトタイプ関数です。

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

_編集_  

あなたのfindが特殊文字を含む場合、それらをエスケープする必要があります:

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

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

93
jesal

更新:

更新には少々時間がかかりますが、私はこの質問に出くわしたので、私の以前の答えは私が満足しているものではないことに気づきました。 1つのWordを置き換えることが質問に含まれていたので、Wordの境界を使用することを誰も考えていませんでした(\b

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

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

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

基本的に、この質問はここの質問と同じです。 Javascriptは "'"を "' '" に置き換えます

@マイク、私がそこに与えた答えをチェックしてください...正規表現は、それからかけ離れて、部分集合の複数の出現を置き換える唯一の方法ではありません。柔軟だと思う、分割する!

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

あるいは、Wordパーツの交換を防ぐために、承認された回答でも問題ありません。この問題を回避するには、正規表現を使用します。正規表現を使用すると、やや複雑になり、その結果として少し遅くなります。

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

出力は、受け入れられた回答と同じですが、この文字列に/ cat/g表現を使用します。

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

本当におっと、これはおそらくあなたが望むものではありません。それでは、何ですか?私見、「猫」を条件付きで置き換える正規表現。 (Wordの一部ではありません)

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の例を追加するかもしれないと思いました。この場合、andという式が劇的に単純化され、正しい大文字に置き換える、またはcatname__とcatsname__の両方を一度に置き換えるなど、さらに柔軟になります。

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

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

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

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

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

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

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

編集: replaceについての説明すべての可用性

'replaceAll'メソッドがStringのプロトタイプに追加されました。これは、すべての文字列オブジェクト/リテラル​​に使用できるようになることを意味します。

例えば。

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

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

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

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

34

正規表現を使う:

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

一重引用符の置き換え

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

    return text;
}
30
Chris Rosete

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

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

方法01:

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

方法02:

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

方法03:

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

方法04:

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

出力:

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

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

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

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

改訂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倍 です。

ここのコメントで指摘されているように、これは:replaceAll("string", "s", "ss")のようにあなたのomit変数がplaceを含んでいる場合はうまくいきません。

私の再帰的置換の変形がさらに速くなる別のjsperfがあります( http://jsperf.com/replace-all-vs-split-join/12 )!

  • 2017年7月27日の更新:最近リリースされたChrome 59では、RegExpのパフォーマンスが最速になったようです。
22
Cole Lawrence
str = str.replace(new RegExp("abc", 'g'), "");

上記の答えよりも私のためによく働いた。そのため、new RegExp("abc", 'g')は、テキスト('g')のすべての発生("abc"フラグ)に一致するものを含むRegExpを作成します。 2番目の部分は、空の文字列("")です。 strは文字列です。replace(...)は結果を返すだけで上書きはしないので、上書きする必要があります。場合によっては、それを使いたくなるかもしれません。

22
csomakk

JavaScript RegExpを使うことはあなたのために仕事をすることができます、単に以下のような何かをしてください、 global のための傑出した/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コードを使用することもできます。再利用したい場合.

21
Alireza

探したいものがすでに文字列の中にあり、正規表現エスケープが手元にない場合は、join/splitを使用できます。

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

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

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

私はこの方法が好きです(それは少しきれいに見えます):

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

http://jsfiddle.net/ANHR9/ /

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

文字列がabcccのような似たようなパターンを含んでいるなら、これを使うことができます:

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

前の答えはあまりにも複雑すぎます。このように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);

11
Black

探している文字列が置き換え後も存在しないようにするには、ループを使用する必要があります。

例えば:

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

完了しても、 'test abc'が表示されます。

これを解決するための最も簡単なループは次のようになります。

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

しかし、それは各サイクルにつき2回の置き換えを実行します。おそらく(投票される危険性があるので)それを組み合わせることで、少し効率的ですが読みにくい形式にすることができます。

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

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

9
SamGoody

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

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

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

あなたは詳細な例を参照することができます ここ

9
Cheezy Code

次の機能は私のために働きます:

String.prototype.replaceAllOccurence = function(str1, str2, ignore)
{
    return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;

今このような関数を呼び出します。

"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");

このコードをブラウザのコンソールにコピーしてTESTに貼り付けるだけです。

7
Sandeep Gantait

下記の方法で簡単に使えます

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

/gを追加するだけです 

document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');

/gはグローバルを意味します

7
Reza Fahmi

私はこの問題を簡単なコードで解決しました。

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

Jsfiddle /の例を確認してください https://jsfiddle.net/pot6whnx/1/ /

7
Riajul Islam

前回の再帰置換の結果を格納するために p を使用します。

function replaceAll(s, m, r, p) {
    return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}

可能になるまで、文字列 s にあるすべての出現箇所を置き換えます。

replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'

無限ループを避けるために、私は置換 r がマッチ m を含んでいるかどうかチェックします。

replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'
6
Termininja

私は分割して参加するか、この機能を使用します

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

ほとんどの人はおそらくURLをエンコードするためにこれをやっています。 URLをエンコードするには、スペースを考慮する必要があるだけでなく、文字列全体をencodeURIで正しく変換する必要があります。

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

取得するため:

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

主な回答に関連するパフォーマンスの観点からは これらはいくつかのオンラインテストです

以下はconsole.time()を使ったいくつかのパフォーマンステストです(あなた自身のコンソールで最もうまくいきますが、スニペットで見るのはとても短いです)

console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')

console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');

console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
    str1 = str1.replace('-', ' ');
}
console.timeEnd('while');

注意すべき興味深いことは、RegExp解は平均的に最速と思われ、whileループ解は最も遅いものの、それらを複数回実行した場合、結果は常に異なることです。

4
Ferie

私の実装、非常に自明

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

あらゆる種類の文字を置き換えるには、次のコードを試してください。

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

それで、この方法はこの問題を解決するでしょう。

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

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

私はAjaxを使用していたので、JSON形式でパラメータを送信する必要がありました。それから私の方法はこのようになります:

 function sendMessage(source, messageID, toProfileID, userProfileID) {

     if (validateTextBox()) {
         var message = $('#message').val();
         message = message.replaceAll('\\', '\\\\');
         message = message.replaceAll('"', '\\"');
         $.ajax({
             type: "POST",
             async: "false",
             contentType: "application/json; charset=utf-8",
             url: "services/WebService1.asmx/SendMessage",
             data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").hide();
                 $("#message").val("");
                 $("#delMessageContainer").show();
                 $("#msgPanel").show();
             },
             error: function (result) {
                 alert("message sending failed");
             }
         });
     }
     else {
         alert("Please type message in message box.");
         $("#message").focus();

     }
 }

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

私のアプリケーションでは、この目的のために最も強力なカスタム関数を使用しています。さらに、split/joinソリューションを単純なケースでラップしても、Chrome 60Firefox 54JSBEN.CH )のほうが少し速いです。 。私のコンピュータはWindows 7 64 bitsを実行しています。

利点は、このカスタム関数が文字列または文字を使用して同時に多くの置換を処理できることです。これは、一部のアプリケーションではショートカットになることがあります。

上記のsplit/joinソリューションのように、以下のソリューションはエスケープ文字を使用しても問題ありません。これは正規表現のアプローチとは異なります。

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

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

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

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

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

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

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

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

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

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

      // found the character or string key in the target

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

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

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

ドキュメントは以下の通りです

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

 Parameters    
 ==========    

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

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

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


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

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

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

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

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

公平を期すために、パラメータテストを行わずに benchmark を実行しました。 

これがNode.jsを使った私のテストセットです。

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

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

そしてその結果:

1 'バナナははるかにdover収穫されたドープフルーツです'
2 'バナナはドーバーから収穫されたドープ果実です。'
3 'バナナは収穫された真実の果実である'
4 'nnn rp frt hrvstd nr th rvr'
5 'ラパの浮遊物としてのバナナ
6「ブヌヌスはウリポフュテフの修道院長である」
7 false
8 false
9 'BANANA IS川の近くで収穫されたRIPEフルーツ
10 'BANANA IS Aドーバーに収穫されたフルーツの実' 

3
Paulo Buchsbaum

これは正規表現を使って実現できます。誰かを助けるかもしれないいくつかの組み合わせ、

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]

複数の連続したスペースを1つのスペースに置き換えるには、

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

すべての*文字を置き換えるには、

console.log(Word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

疑問符(?)を置き換えるには

console.log(Word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

引用符を置き換えるには、

console.log(Word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

すべての '文字を置き換えるには、

console.log(Word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

特定の単語を置き換えるには、

console.log(Word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

バックスラッシュを置き換えるには、

console.log(Word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

スラッシュを置き換えるには、

console.log(Word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

すべてのスペースを置き換えるには

console.log(Word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

ドットを置き換えるには、

console.log(Word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

これがプロトタイプの作業コードです。

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

unique replaceableの値の場合

String.prototype.replaceAll = function(search_array, replacement_array) {
  //
  var target = this;
  //
  search_array.forEach(function(substr, index) {
    if (typeof replacement_array[index] != "undefined") {
      target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
    }
  });
  //
  return target;
};

//  Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);

2
TheAivis

方法1

正規表現を実装しよう

"テストabcテストテストabcテストテストテストabcテストテストabc"。

方法2

分割して参加する。 abcで分割して空のスペースで結合する

"abcテストtest abcテストtest abcテストtest abcをテストします。

2
ashish

ライブラリを使用することがあなたの選択肢であるならば、あなたはライブラリ機能に伴うテストとコミュニティサポートの利益を得るでしょう。たとえば、 string.js ライブラリにはreplaceAll()関数があり、それが探しているものを実行します。

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

文字列の最初の要素を検索して置換する  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

文字列のグローバル検索と置換で  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

2
KARTHIKEYAN.A

最後のバージョンのJavaScriptの機能的な特徴のいくつかに基づいて、私のソリューションを共有したいと思います。

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

   var result = str.split(' ').reduce((a, b) => {
      return b == 'abc' ? a : a + ' ' + b;   })

  console.warn(result)
1
Andrés

これは正規表現とフラグgを使って解決することができます。これは最初のマッチを見つけた後に止まらないことを意味します。本当に、正規表現は命の恩人です!

function replaceAll(string, pattern, replacement) {
    return string.replace(new RegExp(pattern, "g"), replacement);
}

// or if you want myString.replaceAll("abc", "");

String.prototype.replaceAll = function(pattern, replacement) {
    return this.replace(new RegExp(pattern, "g"), replacement);
};
1
C. Morgan

1回限りの交換には

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

複数回置き換えるには:

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

これでうまくいくはずです。

String.prototype.replaceAll = function (search, replacement){
var str1 = this.replace(search, replacement);
var str2 = this;
while(str1 != str2){
str2 = str1;
str1 = str1.replace(search, replacement);
}
return str1;
}

例:

Console.log("Steve is the best character in minecraft".replaceAll("Steve" ,"Alex"));
1
jessie tessie

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

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

この答えをチェックすると役に立つかもしれませんし、私は自分のプロジェクトで使用しました。

function replaceAll(searchString, replaceString, str) {
   return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test  test test  test test test  test test "
0
Raghavendra S

これを試して:

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

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

    return str;
};
0

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;
};
0
Stefan Steiger
 var myName = 'r//i//n//o//l////d';
  var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
  console.log(myValidName);

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

すべての答えは受け入れられます、あなたはこれを多くの方法ですることができます。これをするトリックの1つはこれです。

const str = "Test abc test test abc test test test abc test test abc";

const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) => {
  if (element == compare) {
    arrayStr.splice(index, 1);
  }
});
const newString = arrayStr.join(" ");
console.log(newString);
0
Nouman Dilshad

最も簡単な解決策 -

let str = "Test abc test test abc test test test abc test test abc";

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

Or Simply - 

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

0
Brijesh Kumar

最善の解決策は、任意の文字を置き換えるために、現在の文字列内のmatched Stringprovided Stringに置き換えるためにこれらのindexOf(), includes(), substring()関数を使用することです。

  • String.indexOf() 関数はnを見つけることです番目 インデックス位置と一致します。
  • String.includes() methodは、ある文字列が別の文字列の中にあるかどうかを判断し、必要に応じてtrueまたはfalseを返します。
  • String.substring() functionはStringの部分(precedingexceding)を取得します。これらの部分の間に置換文字列を追加して、最終的な戻り文字列を生成します。

以下の機能は任意の文字を使用することを可能にします。
as RegExp**のような特別な文字を許さず、$のようにエスケープする必要がある文字もあります。

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

テキストとパターンを照合するために正規表現オブジェクトを使うこともできます。以下は正規表現オブジェクトとなる関数です。

'**'のような無効な正規表現パターンを使っているときはSyntaxErrorを受け取るでしょう。

  • String.replace() functionは、指定された文字列を指定された文字列に置き換えるために使用されます。
  • String.match() functionは、文字列が繰り返される回数を見つけることです。
  • RegExp.prototype.test メソッドは、正規表現と指定された文字列の間の一致を検索します。 trueまたはfalseを返します。
String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
    }
    return retStr;
};

正規表現は引用符なしで書かれていることに注意してください。


上記の機能を使用する例:

var str = "yash yas $dfdas.**";
console.log('String : ', str);

// No need to escape any special Character
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
console.log('All Matched replace : ', str.replaceAllMatches({'as' : '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**' : '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX All Matched replace : ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

結果:

String :  yash yas $dfdas.**
Index Matched replace :  yash yas $dfd*.**
Index Matched replace :  yash ~as $dfdas.**

All Matched replace :  Y**h Y** -dfd**.**
All Matched replace :  yash yas %$%dfdas.>>

REGEX All Matched replace :  Y**h Y** -dfd**.**

0
Yash