จะแทนที่สตริงที่เกิดขึ้นทั้งหมดได้อย่างไร?

ฉันมีสายนี้:

"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ฟังก์ชันข้างต้นโดยไม่ต้องประมวลผลล่วงหน้าเพื่อหลีกเลี่ยงอักขระเหล่านั้น สิ่งนี้ครอบคลุมอยู่ในคู่มือ JavaScriptของเครือข่ายนักพัฒนา MozillaของRegular Expressionsซึ่งจะมีฟังก์ชั่นยูทิลิตี้ต่อไปนี้ (ซึ่งมีการเปลี่ยนแปลงอย่างน้อยสองครั้งตั้งแต่คำตอบนี้ถูกเขียนขึ้นในตอนแรกดังนั้นโปรดตรวจสอบเว็บไซต์ 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);
}

เพื่อความสมบูรณ์ฉันได้คิดเกี่ยวกับวิธีที่ฉันควรใช้ในการทำเช่นนี้ โดยทั่วไปมีสองวิธีในการทำเช่นนี้ตามคำแนะนำโดยคำตอบอื่น ๆ ในหน้านี้

หมายเหตุ:โดยทั่วไปแล้วไม่แนะนำให้ขยายต้นแบบที่มีอยู่แล้วใน 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);
};

ไม่ทราบมากเกินไปเกี่ยวกับวิธีการแสดงออกปกติทำงานเบื้องหลังในแง่ของประสิทธิภาพฉันมักจะโน้มตัวไปทางแยกและเข้าร่วมการใช้งานในอดีตโดยไม่คิดเกี่ยวกับประสิทธิภาพ เมื่อฉันสงสัยว่าสิ่งใดมีประสิทธิภาพมากกว่าและด้วยระยะขอบฉันใช้มันเป็นข้ออ้างในการค้นหา

เมื่อวันที่ 8 เครื่อง Chrome ของ Windows, การดำเนินงานที่แสดงออกปกติตามที่เร็วที่สุดด้วยการแยกและเข้าร่วมการดำเนินงานเป็น 53% ช้า ความหมายของนิพจน์ทั่วไปนั้นเร็วเป็นสองเท่าสำหรับอินพุต lorem ipsum ที่ฉันใช้

ตรวจสอบเกณฑ์มาตรฐานนี้ที่รันการใช้งานสองแบบนี้ต่อกัน

ตามที่ระบุไว้ในความคิดเห็นด้านล่างโดย @ThomasLeduc และคนอื่น ๆ อาจจะมีปัญหากับการดำเนินงานที่แสดงออกตามปกติถ้าsearchมีอักขระบางอย่างที่จะถูกสงวนไว้เป็นอักขระพิเศษในการแสดงออกปกติ การนำไปใช้จะถือว่าผู้เรียกใช้จะหลีกเลี่ยงสตริงก่อนหรือจะผ่านสตริงที่ไม่มีอักขระในตารางในRegular Expressions (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"

นี่คือ regex ง่าย ๆ ที่หลีกเลี่ยงการแทนที่ส่วนของคำในกรณีส่วนใหญ่ อย่างไรก็ตามเส้นประ-ยังถือว่าเป็นขอบเขตของคำ ดังนั้นเงื่อนไขสามารถใช้ในกรณีนี้เพื่อหลีกเลี่ยงการแทนที่สตริงเช่น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 ไม่ใช่วิธีเดียวที่จะแทนที่การเกิดขึ้นหลายครั้งของการสมัครสมาชิก คิดว่ายืดหยุ่นคิดแยก!

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, regex ที่แทนที่ '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

จับคู่กับนิพจน์ทั่วไปทั่วโลก:

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

สำหรับการเปลี่ยนใช้ครั้งเดียว:

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 จากที่นี่:

อะไรคือวิธีการจาวาสคริปต์ที่มีประโยชน์ที่ขยายวัตถุในตัว?

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

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

แก้ไข:ชี้แจงเกี่ยวกับการแทนที่ว่างทั้งหมด

วิธีการ '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, '');

หากคุณคิดว่านำกลับมาใช้ใหม่ให้สร้างฟังก์ชันเพื่อทำสิ่งนั้นให้คุณ แต่ไม่แนะนำเพราะมันเป็นเพียงฟังก์ชั่นหนึ่งบรรทัด แต่อีกครั้งถ้าคุณใช้อย่างหนักคุณสามารถเขียนดังนี้:

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

แต่อย่างที่ฉันพูดถึงก่อนหน้านี้มันจะไม่สร้างความแตกต่างอย่างมากในแง่ของการเขียนบรรทัดหรือประสิทธิภาพการแคชเฉพาะฟังก์ชั่นอาจส่งผลต่อประสิทธิภาพการทำงานที่รวดเร็วขึ้นในสตริงยาว

สมมติว่าคุณต้องการแทนที่ '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')สร้าง RegExp สิ่งที่ตรงกับการเกิดขึ้นทั้งหมด ( 'g'ธง) ของข้อความ ( "abc") ส่วนที่สองคือสิ่งที่ถูกแทนที่ในกรณีที่คุณว่างสตริง ( "") 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)
}

มันเกือบสองเท่าเร็วกว่าการแยกและเข้าร่วม

ตามที่ระบุไว้ในความคิดเห็นที่นี่สิ่งนี้จะไม่ทำงานหากomitตัวแปรของคุณมีplaceดังเช่นใน:replaceAll("string", "s", "ss")เพราะจะสามารถแทนที่คำอื่นที่เกิดขึ้นได้เสมอ

มี jsperf อีกชุดที่มีชุดคำสั่งแทนที่แบบเรียกซ้ำของฉันซึ่งทำงานได้เร็วขึ้น ( http://jsperf.com/replace-all-vs-split-join/12 )

• อัปเดต 27 กรกฎาคม 2560: ดูเหมือนว่าตอนนี้ RegExp จะมีประสิทธิภาพการทำงานที่เร็วที่สุดใน Chrome 59 ที่เพิ่งเปิดตัว

ประสิทธิภาพ

วันนี้ 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: เกินขนาดสแต็กการโทรสูงสุด

สำหรับตัวละคร 1M พวกเขายังทำลาย Chrome ได้

ฉันพยายามทำการทดสอบ 1M อักขระสำหรับโซลูชันอื่น ๆ แต่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>

หากสิ่งที่คุณต้องการค้นหานั้นมีอยู่ในสตริงอยู่แล้วและคุณไม่มี regex ที่เป็นประโยชน์คุณสามารถใช้การเข้าร่วม / การแยก:

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

วิธีที่ง่ายที่สุดในการทำเช่นนี้โดยไม่ใช้ regex ใด ๆ จะถูกแบ่งและเข้าร่วมเหมือนรหัสที่นี่:

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

คำตอบก่อนหน้านี้ซับซ้อนเกินไป เพียงใช้ฟังก์ชั่นแทนที่เช่นนี้

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, '');
}

แต่มันจะทำการแทนที่สองครั้งในแต่ละรอบ บางที (มีความเสี่ยงที่จะถูกลงคะแนน) ที่สามารถรวมกันเป็นรูปแบบที่มีประสิทธิภาพมากกว่า แต่อ่านได้น้อยกว่า:

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

สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อค้นหาสตริงที่ซ้ำกัน
ตัวอย่างเช่นหากเรามี 'a ,,, b' และเราต้องการลบเครื่องหมายจุลภาคที่ซ้ำกันทั้งหมด
[ในกรณีนั้นเราสามารถทำ. แทนที่ (/, + / g, ',') แต่ในบางจุด regex มีความซับซ้อนและช้าพอที่จะวนลูปแทน]

แม้ว่าผู้คนจะพูดถึงการใช้ regex แต่มีวิธีที่ดีกว่าถ้าคุณต้องการแทนที่ข้อความโดยไม่คำนึงถึงตัวอักษรของข้อความ ชอบตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก ใช้ไวยากรณ์ด้านล่าง

//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 หมายถึงทั่วโลก