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


Answers

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

टिप्पणी के जवाब में:

var find = 'abc';
var re = new RegExp(find, 'g');

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

अपवोट की टिप्पणी को क्लिक करने के जवाब में, आप इसे और भी सरल बना सकते हैं:

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

नोट: नियमित अभिव्यक्ति में विशेष (मेटा) वर्ण होते हैं, और जैसा कि उन वर्णों से बचने के लिए पूर्व-प्रसंस्करण के बिना उपरोक्त find फ़ंक्शन में एक आक्षेप को अंधाधुंध रूप से पारित करने के लिए खतरनाक होता है यह मोज़िला डेवलपर नेटवर्क के जावास्क्रिप्ट गाइड पर नियमित अभिव्यक्तियों में शामिल है , जहां वे निम्न उपयोगिता कार्य प्रस्तुत करते हैं:

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

तो सुरक्षित से ऊपर सभी replaceAll() फ़ंक्शन को बनाने के लिए, यदि आप escapeRegExp शामिल escapeRegExp हैं, तो इसे निम्न में संशोधित किया जा सकता है:

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

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

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

करते हुए

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

केवल ऊपर की स्ट्रिंग में abc की पहली घटना को हटाते हुए लगता है मैं इसे सभी घटनाओं की जगह कैसे कर सकता हूं?




एक यूआरएल को एनकोड करने के लिए ज्यादातर लोग ऐसा कर रहे हैं। एक यूआरएल को सांकेतिकृत करने के लिए, आपको केवल रिक्त स्थान पर विचार नहीं करना चाहिए, बल्कि पूरे स्ट्रिंग को ठीक से encodeURI कनवर्ट करना चाहिए।

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

लेना:

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



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



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



g ध्वज सेट के साथ एक नियमित अभिव्यक्ति का उपयोग करना सभी को बदल देगा:

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

यहाँ भी देखें




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

संशोधित जेस्परफ़

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 में रेगएक्सपी का अब तक का सबसे तेज प्रदर्शन है।



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

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

उपयोगी जावास्क्रिप्ट विधियाँ जो अंतर्निहित ऑब्जेक्ट्स का विस्तार करती हैं?

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

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

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

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

उदाहरण के लिए

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



सभी प्रकार के वर्णों को बदलने के लिए, इस कोड का प्रयास करें:

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 \\"*/

मैं अजाक्स का उपयोग कर रहा था, और मुझे 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);
 };



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

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

someString = 'the cat looks like a cat';
anotherString = replaceMulti(someString, 'cat', 'dog');



आप बस नीचे विधि का उपयोग कर सकते हैं

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



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

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

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




मेरा क्रियान्वयन, बहुत आत्म व्याख्यात्मक

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



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




function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        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"

यह एक सरल regex है जो अधिकांश मामलों में शब्दों के कुछ हिस्सों को बदलने से बचा जाता है। हालांकि, एक डैश - अब भी एक शब्द सीमा माना जाता है। इसलिए इस स्थिति में cool-cat बॉल का उपयोग 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 एक 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" ?? 

ओह वास्तव में, यह संभवत: वह नहीं है जो आप चाहते हैं। तो क्या है? आईएमएचओ, एक regex जो केवल 'बिल्ली' की बजाय कथित रूप से बदलता है (यानी किसी शब्द का हिस्सा नहीं), ऐसा ही है:

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

अंतिम अतिरिक्त:

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