සාමාන්‍ය ප්‍රකාශනයක ඔබ විචල්‍යයක් භාවිතා කරන්නේ කෙසේද?

මම String.replaceAll()ජාවාස්ක්‍රිප්ට් හි ක්‍රමවේදයක් නිර්මාණය කිරීමට කැමති අතර මම සිතන්නේ රීජෙක්ස් භාවිතා කිරීම එය කිරීමට වඩාත්ම දැඩි ක්‍රමය වනු ඇති බවයි. කෙසේ වෙතත්, විචල්‍යය රීජෙක්ස් වෙත යොමු කරන්නේ කෙසේදැයි මට සිතාගත නොහැක. සියලු අවස්ථා වෙනුවට වන මම මේ මේ දේ කළ හැකි "B"සමග "A".

"ABABAB".replace(/B/g, "A");

නමුත් මට මේ වගේ දෙයක් කිරීමට අවශ්‍යයි:

String.prototype.replaceAll = function(replaceThis, withThis) {
    this.replace(/replaceThis/g, withThis);
};

නමුත් පැහැදිලිවම මෙය ප්‍රතිස්ථාපනය කරන්නේ පෙළ පමණි "replaceThis"... ඉතින් මම මෙම විචල්‍යය මගේ රීජෙක්ස් නූලට යොමු කරන්නේ කෙසේද?

/regex/gසින්ටැක්ස් භාවිතා කරනවා වෙනුවට , ඔබට නව RegExp වස්තුවක් සෑදිය හැකිය:

var replace = "regex";
var re = new RegExp(replace,"g");

ඔබට මේ ආකාරයෙන් රීජෙක්ස් වස්තු ගතිකව නිර්මාණය කළ හැකිය. එවිට ඔබ කරනු ඇත:

"mystring".replace(re, "newstring");

එරික් වෙන්ඩලින් සඳහන් කළ පරිදි, ඔබට මේ වගේ දෙයක් කළ හැකිය:

str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");

මෙය අස්වැන්නක් ලබා දෙයි "regex matching .". කෙසේ වෙතත්, str1 නම් එය අසාර්ථක වනු ඇත ".". "pattern matching regex"කාල පරිච්ඡේදය ප්‍රතිස්ථාපනය කරමින් ප්‍රති result ලය ලැබෙනු ඇතැයි ඔබ අපේක්ෂා "regex"කළත් එය එසේ වනු ඇත ...

regexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregex

මෙයට හේතුව, "."සංගීත භාණ්ඩයක් වුවද , රෙජීඑක්ස්පී ඉදිකිරීම්කරු තුළ එය තවමත් සාමාන්‍ය ප්‍රකාශනයක් ලෙස අර්ථකථනය කර ඇති අතර, එහි අර්ථය වන්නේ රේඛීය නොවන බිඳෙන අක්‍ෂරයකි. මෙම කාර්යය සඳහා, පහත සඳහන් කාර්යය ප්‍රයෝජනවත් විය හැකිය:

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

එවිට ඔබට කළ හැකිය:

str1 = "."
var re = new RegExp(RegExp.quote(str1), "g");
"pattern matching .".replace(re, "regex");

අස්වැන්න "pattern matching regex".

"ABABAB".replace(/B/g, "A");

සෑම විටම මෙන්: ඔබට අවශ්‍ය නම් හැර regex භාවිතා නොකරන්න. සරල නූල් ප්‍රතිස්ථාපනය සඳහා, මෝඩය:

'ABABAB'.split('B').join('A')

එවිට ඔබට ග්‍රේසෙනොට්ස්ගේ පිළිතුරේ සඳහන් කර ඇති කරුණු ගැන කරදර විය යුතු නැත.

ඔබට සියලු සිදුවීම් ( g) ලබා ගැනීමට අවශ්‍ය නම් , සිද්ධි සංවේදී නොවීම ( i) කර මායිම් භාවිතා කරන්න, එය වෙනත් වචනයක් තුළ වචනයක් නොවන පරිදි ( \\b):

re = new RegExp(`\\b${replaceThis}\\b`, 'gi');

උදාහරණයක්:

let inputString = "I'm John, or johnny, but I prefer john.";
let replaceThis = "John";
let re = new RegExp(`\\b${replaceThis}\\b`, 'gi');
console.log(inputString.replace(re, "Jack")); // I'm Jack, or johnny, but I prefer Jack.

ගැලපුම් ක්‍රමය සමඟ විචල්‍යය භාවිතා කිරීමට බලාපොරොත්තු වන ඕනෑම කෙනෙකුට , මෙය මට වැඩ කළේය

var alpha = 'fig';
'food fight'.match(alpha + 'ht')[0]; // fight

මෙය:

var txt=new RegExp(pattern,attributes);

මෙයට සමාන වේ:

var txt=/pattern/attributes;

Http://www.w3schools.com/jsref/jsref_obj_regexp.asp බලන්න .

this.replace( new RegExp( replaceThis, 'g' ), withThis );

නිත්‍ය ප්‍රකාශනය ගතිකව ගොඩනඟා ගැනීමට ඔබට අවශ්‍ය වන අතර මේ සඳහා නිසි ද්‍රාවණය වන්නේ new RegExp(string)ඉදිකිරීම්කරු භාවිතා කිරීමයි . ඉදිකිරීම්කරුට විශේෂ අක්ෂර වචනාර්ථයෙන් සැලකීමට නම් , ඔබ ඒවායින් ගැලවිය යුතුය. ඉදි-තුළ කටයුතු දක්නට ඇති අතර සඟවන්න UI විජට් autocomplete කැඳවා $.ui.autocomplete.escapeRegex:

[...] ඔබට සාදන ලද $.ui.autocomplete.escapeRegexශ්‍රිතය භාවිතා කළ හැකිය . එය තනි වචන තර්කයක් ගෙන සියලු රීජෙක්ස් අක්ෂර වලින් ගැලවී ප්‍රති result ලය සුරක්ෂිත කරයි new RegExp().

ඔබ jQuery UI භාවිතා කරන්නේ නම් ඔබට එම ශ්‍රිතය භාවිතා කළ හැකිය, නැතහොත් එහි අර්ථ දැක්වීම ප්‍රභවයෙන් පිටපත් කරන්න :

function escapeRegex( value ) {
    return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
}

එය මේ ආකාරයට භාවිතා කරන්න:

"[z-a][z-a][z-a]".replace(new RegExp(escapeRegex("[z-a]"), "g"), "[a-z]");
//            escapeRegex("[z-a]")       -> "\[z\-a\]"
// new RegExp(escapeRegex("[z-a]"), "g") -> /\[z\-a\]/g
// end result                            -> "[a-z][a-z][a-z]"

String.prototype.replaceAll = function (replaceThis, withThis) {
   var re = new RegExp(replaceThis,"g"); 
   return this.replace(re, withThis);
};
var aa = "abab54..aba".replaceAll("\\.", "v");

මෙම මෙවලම සමඟ පරීක්ෂා කරන්න

String.prototype.replaceAll = function(a, b) {
    return this.replace(new RegExp(a.replace(/([.?*+^$[\]\\(){}|-])/ig, "\\$1"), 'ig'), b)
}

එය මෙසේ පරීක්ෂා කරන්න:

var whatever = 'Some [b]random[/b] text in a [b]sentence.[/b]'

console.log(whatever.replaceAll("[", "<").replaceAll("]", ">"))

මෙන්න තවත් ප්‍රතිස්ථාපනය සියලු ක්‍රියාත්මක කිරීම:

    String.prototype.replaceAll = function (stringToFind, stringToReplace) {
        if ( stringToFind == stringToReplace) return this;
        var temp = this;
        var index = temp.indexOf(stringToFind);
        while (index != -1) {
            temp = temp.replace(stringToFind, stringToReplace);
            index = temp.indexOf(stringToFind);
        }
        return temp;
    };

නිත්‍ය ප්‍රකාශනයකට විචල්‍ය / අන්වර්ථ / ශ්‍රිතයක් ඇතුළත් කිරීමේ මගේ අවශ්‍යතාවය සපුරාලීම සඳහා, මා ඉදිරිපත් කළේ මෙයයි:

oldre = /xx\(""\)/;
function newre(e){
    return RegExp(e.toString().replace(/\//g,"").replace(/xx/g, yy), "g")
};

String.prototype.replaceAll = this.replace(newre(oldre), "withThis");

එහිදී 'ඕල්ඩ්‍රේ' යනු මට විචල්‍යයක් ඇතුළු කිරීමට අවශ්‍ය මුල් රීජෙක්ස්ප් වන අතර, 'xx' යනු එම විචල්‍යය / අන්වර්ථය / ශ්‍රිතය සඳහා ස්ථාන දරන්නා වන අතර 'yy' යනු සත්‍ය විචල්‍ය නාමය, අන්වර්ථය හෝ ශ්‍රිතයයි.

මෙය # 2 ගූගල් ප්‍රති result ලය බැවින් ස්ටීවන් පෙනිගේ පිළිතුරේ කෝපි පිටපත් අනුවාදය .... කෝපි යනු අක්ෂර විශාල ප්‍රමාණයක් ඉවත් කර ඇති ජාවාස්ක්‍රිප්ට් වුවද ...;)

baz = "foo"
filter = new RegExp(baz + "d")
"food fight".match(filter)[0] // food

මගේ විශේෂ අවස්ථාවෙහිදී

robot.name=hubot
filter = new RegExp(robot.name)
if msg.match.input.match(filter)
  console.log "True!"

ඔබට ගතිකව සාදන ලද RegExp (මෙම ප්‍රශ්නයට අනෙක් ප්‍රතිචාර අනුව) සෑදිය හැකි අතර, මම මගේ අදහස සමාන පෝස්ට් එකකින් ප්‍රතිරාවය කරමි : String.replace () හි ක්‍රියාකාරී ස්වරූපය අතිශයින්ම ප්‍රයෝජනවත් වන අතර බොහෝ අවස්ථාවලදී අවශ්‍යතාවය අඩු කරයි ගතිකව සාදන ලද RegExp වස්තු. (මෙය යම් ආකාරයක වේදනාකාරී හේතුවක් වන අතර, ඔබ කප්පාදුව / [AZ] + / regexp වචනානුගත ආකෘතිය භාවිතා කරනවාට වඩා රෙජෙක්ස්ප් ඉදිකිරීම්කරුට නූලක් ලෙස ප්‍රකාශ කළ යුතුය)

$ 1 ඔබ සමඟ වැඩ නොකරන්නේ නම් ඔබට මෙය භාවිතා කළ හැකිය

var pattern = new RegExp("amman","i");
"abc Amman efg".replace(pattern,"<b>"+"abc Amman efg".match(pattern)[0]+"</b>");

ඔබට සෑම විටම indexOfනැවත නැවත භාවිතා කළ හැකිය :

String.prototype.replaceAll = function(substring, replacement) {
    var result = '';
    var lastIndex = 0;

    while(true) {
        var index = this.indexOf(substring, lastIndex);
        if(index === -1) break;
        result += this.substring(lastIndex, index) + replacement;
        lastIndex = index + substring.length;
    }

    return result + this.substring(lastIndex);
};

ආදේශනය තරගය අඩංගු වන විට මෙය අනන්ත පුඩුවක් තුළට නොයනු ඇත.

ඔබේ විසඳුම මෙහි ඇත:

සාමාන්‍ය ප්‍රකාශනයකට විචල්‍යයක් පසු කරන්න.

මා ක්‍රියාවට නංවා ඇත්තේ ඔබට ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය පෙළ ක්ෂේත්‍රයකින් වටිනාකම ලබා ගැනීම සහ තවත් එකක් “ප්‍රතිස්ථාපනය කරන්න” පෙළ ක්ෂේත්‍රය, පෙළ ක්ෂේත්‍රයෙන් අගය විචල්‍යයකින් ලබා ගැනීම සහ විචල්‍යය RegExp වෙත සැකසීම ය. තවදුරටත් ප්‍රතිස්ථාපනය කිරීමට ක්‍රියා කරයි. මගේ නඩුවේදී මම Jquery භාවිතා කරමි, ඔබටද එය කළ හැක්කේ JavaScript මගින් පමණි.

ජාවාස්ක්‍රිප්ට් කේතය:

  var replace =document.getElementById("replace}"); // getting a value from a text field with I want to replace
  var replace_with = document.getElementById("with"); //Getting the value from another text fields with which I want to replace another string.

  var sRegExInput = new RegExp(replace, "g");    
  $("body").children().each(function() {
    $(this).html($(this).html().replace(sRegExInput,replace_with));
  });

මෙම කේතය බොත්තමක ​​ඔන්ක්ලික් සිදුවීම මත ඇත, ඔබට මෙය ඇමතීමට ශ්‍රිතයක් තුළ තැබිය හැකිය.

දැන් ඔබට ප්‍රතිස්ථාපන ශ්‍රිතය තුළ විචල්‍යය සමත් කළ හැකිය.

මෙම ස්වයං ඇමතුම් ශ්‍රිතය දර්ශකයක් භාවිතා කරමින් ප්‍රතිස්ථාපක අයිතම හරහා නැවත ක්‍රියා කරයි, සහ එක් එක් පාස් සමඟ නූල් මත ගෝලීයව ප්‍රතිස්ථාපක අයිතම [දර්ශකය] වෙනස් කරයි.

  const replacerItems = ["a", "b", "c"];    

    function replacer(str, index){
          const item = replacerItems[index];
          const regex = new RegExp(`[${item}]`, "g");
          const newStr = str.replace(regex, "z");
          if (index < replacerItems.length - 1) {
            return replacer(newStr, index + 1);
          }
          return newStr;
    }

// console.log(replacer('abcdefg', 0)) will output 'zzzdefg'

මෙම පිළිතුරු කිසිවක් මට පැහැදිලි නැත. අවසානයේදී මට හොඳ පැහැදිලි කිරීමක් http://burnignorance.com/php-programming-tips/how-to-use-a-variable-in-replace-function-of-javascript/

සරල පිළිතුර නම්:

var search_term = new RegExp(search_term, "g");    
text = text.replace(search_term, replace_term);

උදාහරණයක් වශයෙන්:

$("button").click(function() {
  Find_and_replace("Lorem", "Chocolate");
  Find_and_replace("ipsum", "ice-cream");
});

function Find_and_replace(search_term, replace_term) {
  text = $("textbox").html();
  var search_term = new RegExp(search_term, "g");
  text = text.replace(search_term, replace_term);
  $("textbox").html(text);
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<textbox>
  Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum Lorem ipsum
</textbox>
<button>Click me</button>

නිත්‍ය ප්‍රකාශන නොමැතිව බහුවිධ ප්‍රතිස්ථාපනය සඳහා මම පහත සඳහන් දෑ සමඟ ගියෙමි.

      let str = "I am a cat man. I like cats";
      let find = "cat";
      let replace = "dog";


      // Count how many occurrences there are of the string to find 
      // inside the str to be examined.
      let findCount = str.split(find).length - 1;

      let loopCount = 0;

      while (loopCount < findCount) 
      {
        str = str.replace(find, replace);
        loopCount = loopCount + 1;
      }  

      console.log(str);
      // I am a dog man. I like dogs

විසඳුමේ වැදගත් කොටස මෙහි සොයා ගන්නා ලදී