javascript जावास्क्रिप्ट में एक स्ट्रिंग की सभी घटनाओं को कैसे बदलें?




regex string (24)

मेरे पास यह स्ट्रिंग है:

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

करते हुए

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

ऐसा लगता है कि उपर्युक्त स्ट्रिंग में केवल abc की पहली घटना को हटा दें। मैं इसकी सभी घटनाओं को कैसे बदल सकता हूं?


यह सबसे तेज़ संस्करण है जो नियमित अभिव्यक्तियों का उपयोग नहीं करता है

संशोधित जेएसपीआरएफ

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 जुलाई 2017 को अपडेट करें: ऐसा लगता है कि हाल ही में जारी किए गए क्रोम 59 में RegExp का सबसे तेज़ प्रदर्शन है।

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

पूर्णता के लिए, मुझे यह सोचने के लिए सोचना पड़ा कि मुझे यह करने के लिए किस विधि का उपयोग करना चाहिए। इस पृष्ठ पर अन्य उत्तरों द्वारा सुझाए गए अनुसार इसे करने के मूल रूप से दो तरीके हैं।

नोट: सामान्य रूप से, जावास्क्रिप्ट में अंतर्निहित प्रोटोटाइप को विस्तारित करने की आमतौर पर अनुशंसा नहीं की जाती है। मैं चित्रण के उद्देश्यों के लिए स्ट्रिंग प्रोटोटाइप पर विस्तार के रूप में प्रदान कर रहा हूं, 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 मशीन पर, नियमित अभिव्यक्ति आधारित कार्यान्वयन सबसे तेज़ है , विभाजन के साथ और कार्यान्वयन में 53% धीमी है । मेरे द्वारा उपयोग किए जाने वाले लोरेम इप्सम इनपुट के लिए नियमित अभिव्यक्ति दो गुना तेज होती है।

एक दूसरे के खिलाफ इन दो कार्यान्वयन को चलाने वाले इस benchmark देखें।

जैसा कि @ थॉमस लेडुक और अन्य द्वारा नीचे दी गई टिप्पणी में उल्लेख किया गया है, नियमित अभिव्यक्ति-आधारित कार्यान्वयन के साथ कोई समस्या हो सकती है यदि search में कुछ वर्ण हैं जो नियमित अभिव्यक्तियों में विशेष वर्णों के रूप में आरक्षित हैं। कार्यान्वयन मानता है कि कॉलर पहले से स्ट्रिंग से बच जाएगा या केवल नियमित अभिव्यक्तियों (एमडीएन) में तालिका में वर्णों के बिना तारों को पार करेगा।

एमडीएन हमारे तारों से बचने के लिए एक कार्यान्वयन भी प्रदान करता है। यह अच्छा होगा अगर इसे RegExp.escape(str) रूप में भी मानकीकृत किया गया था, लेकिन RegExp.escape(str) , यह अस्तित्व में नहीं है:

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

हम escapeRegExp को हमारे String.prototype.replaceAll कार्यान्वयन के भीतर कॉल कर सकते हैं, हालांकि, मुझे यकीन नहीं है कि यह प्रदर्शन को कितना प्रभावित करेगा (संभावित रूप से उन स्ट्रिंग्स के लिए भी, जिनके लिए बचने की आवश्यकता नहीं है, जैसे सभी अल्फान्यूमेरिक स्ट्रिंग्स)।


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

http://jsfiddle.net/ANHR9/


यदि आप यह सुनिश्चित करने की कोशिश कर रहे हैं कि जिस स्ट्रिंग को आप ढूंढ रहे हैं वह प्रतिस्थापन के बाद भी मौजूद नहीं होगा, आपको लूप का उपयोग करने की आवश्यकता है।

उदाहरण के लिए:

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

पूरा होने पर, आपके पास अभी भी 'टेस्ट एबीसी' होगा!

इसे हल करने के लिए सबसे सरल पाश होगा:

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 '!

डुप्लिकेट स्ट्रिंग की तलाश करते समय यह विशेष रूप से उपयोगी हो सकता है।
उदाहरण के लिए, यदि हमारे पास 'ए, बी' है और हम सभी डुप्लिकेट कॉमा को हटाना चाहते हैं।
[उस स्थिति में, कोई भी कर सकता है। स्थान (/, + / g, ','), लेकिन किसी बिंदु पर रेगेक्स जटिल हो जाता है और इसके बजाय लूप के लिए पर्याप्त धीमा हो जाता है।]


अद्यतन करें:

यह अपडेट के लिए कुछ देर हो चुकी है, लेकिन चूंकि मैंने इस सवाल पर ठोकर खाई, और देखा कि मेरा पिछला जवाब ऐसा नहीं है जिसे मैं खुश हूं। चूंकि एक शब्द को प्रतिस्थापित करने में शामिल प्रश्न, यह अविश्वसनीय है कि कोई भी शब्द सीमाओं का उपयोग करने के बारे में सोचा नहीं है ( \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"

मूल रूप से, यह प्रश्न यहां प्रश्न के समान ही है: जावास्क्रिप्ट "" "के साथ" '"को प्रतिस्थापित करता है

@ माइक, मैंने जो जवाब दिया है उसे जांचें ... 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 का एक उदाहरण जोड़ सकता हूं। इस मामले में, यह अभिव्यक्ति को नाटकीय रूप से सरल बनाता है और अधिक लचीलापन प्रदान करता है, जैसे सही पूंजीकरण के साथ प्रतिस्थापित करना या 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

जावास्क्रिप्ट में RegExp का उपयोग करना आपके लिए काम कर सकता है, बस बस कुछ ऐसा करें:

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

यदि आप पुन: उपयोग करने के बारे में सोचते हैं, तो आपके लिए ऐसा करने के लिए एक फ़ंक्शन बनाएं, लेकिन इसकी अनुशंसा नहीं की जाती है क्योंकि यह केवल एक पंक्ति कार्य है, लेकिन फिर यदि आप इसका उपयोग करते हैं, तो आप इस तरह कुछ लिख सकते हैं:

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

और बस इसे अपने कोड में नीचे और नीचे की तरह उपयोग करें:

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

लेकिन जैसा कि मैंने पहले उल्लेख किया था, यह लिखित या प्रदर्शन के लिए लाइनों के संदर्भ में एक बड़ा अंतर नहीं देगा, केवल फ़ंक्शन को कैशिंग करने से लंबे तारों पर कुछ तेज प्रदर्शन हो सकता है और यदि आप पुन: उपयोग करना चाहते हैं तो भी DRY कोड का अच्छा अभ्यास कर सकते हैं।


केस-सेंसिटीविटी को जोड़कर इस ऑनलाइनर रेगेक्स का पालन करें, इसलिए यदि आप "एबीसी" करते हैं, तो यह "एबीसी" के समान ही कार्य करेगा।

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

मुझे यह विधि पसंद है (यह थोड़ा क्लीनर दिखता है):

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

var string  = 'Test abc Test abc Test abc Test abc'
string = string.replace(/abc/g, '')
console.log(string)

नोट: वास्तविक कोड में इसका उपयोग न करें।

एक साधारण शाब्दिक स्ट्रिंग के लिए नियमित अभिव्यक्तियों के विकल्प के रूप में, आप इसका उपयोग कर सकते हैं

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

सामान्य पैटर्न है

str.split(search).join(replacement)

यह कुछ मामलों में replaceAll और नियमित अभिव्यक्ति का उपयोग करने से अधिक तेज़ होता था, लेकिन यह आधुनिक ब्राउज़र में अब और मामला प्रतीत नहीं होता है। इसलिए, वास्तविक शब्द में नहीं, नियमित अभिव्यक्ति से बचने की आवश्यकता से बचने के लिए इसे वास्तव में केवल एक त्वरित हैक के रूप में उपयोग किया जाना चाहिए।


g फ्लैग सेट के साथ नियमित अभिव्यक्ति का उपयोग करना सभी को प्रतिस्थापित करेगा:

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

यहां भी देखें


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

उपरोक्त उत्तरों की तुलना में मेरे लिए बेहतर काम किया। तो new RegExp("abc", 'g') एक RegExp बनाता है जो पाठ के सभी अवसर ( 'g' ध्वज) से मेल खाता है ( "abc" )। दूसरे भाग को आपके मामले में खाली स्ट्रिंग ( "" ) में बदल दिया जाता है। str स्ट्रिंग है, और हमें इसे ओवरराइड करना है, क्योंकि replace(...) केवल परिणाम देता है, लेकिन ओवरराइड नहीं करता है। कुछ मामलों में आप इसका उपयोग करना चाहेंगे।


मान लें कि आप 'एक्स' के साथ सभी 'एबीसी' को प्रतिस्थापित करना चाहते हैं:

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

मैं स्ट्रिंग प्रोटोटाइप को संशोधित करने से कुछ और सरल के बारे में सोचने की कोशिश कर रहा था।


आप इन दो शक्तिशाली तरीकों को संयोजित करने का प्रयास कर सकते हैं।

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

आशा करता हूँ की ये काम करेगा!


सिंगल कोट्स को बदलना:

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

    return text;
}

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

या यहां से सभी फ़ंक्शन को प्रतिस्थापित करने का प्रयास करें:

उपयोगी जावास्क्रिप्ट विधियां क्या हैं जो अंतर्निहित वस्तुओं को बढ़ाती हैं?

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

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

संपादित करें: प्रतिस्थापन के बारे में स्पष्टीकरण सभी उपलब्धता

स्ट्रिंग के प्रोटोटाइप में 'replaceAll' विधि जोड़ दी गई है। इसका मतलब है कि यह सभी स्ट्रिंग ऑब्जेक्ट्स / लिटरल्स के लिए उपलब्ध होगा।

उदाहरण के लिए

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

यद्यपि लोगों ने रेगेक्स के उपयोग का उल्लेख किया है, लेकिन यदि आप पाठ के मामले के बावजूद पाठ को प्रतिस्थापित करना चाहते हैं तो बेहतर दृष्टिकोण है। अपरकेस या लोअरकेस की तरह। नीचे वाक्यविन्यास का प्रयोग करें

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

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

आप here विस्तृत उदाहरण देख सकते हैं।


यदि आप जो खोजना चाहते हैं वह पहले से ही एक स्ट्रिंग में है, और आपके पास रेगेक्स एस्केपर आसान नहीं है, तो आप जुड़ें / विभाजित कर सकते हैं:

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

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


निम्नलिखित कार्य मेरे लिए काम करता है:

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

बस इस कोड को अपने ब्राउज़र कंसोल में टेस्ट में कॉपी और पेस्ट करें।


मैं पिछले रिकर्सन प्रतिस्थापन से परिणाम स्टोर करने के लिए पी का उपयोग करता हूं:

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

यह स्ट्रिंग एस में सभी घटनाओं को तब तक बदल देगा जब तक यह संभव न हो:

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

अनंत लूप से बचने के लिए मैं जांचता हूं कि प्रतिस्थापन आर में एक मिलान मीटर है या नहीं :

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

स्वीकृत उत्तर के आधार पर एक स्ट्रिंग प्रोटोटाइप फ़ंक्शन यहां दिया गया है:

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/


नियमित अभिव्यक्ति का प्रयोग करें:

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

बस जोड़ें /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 मतलब वैश्विक है





replace