නූලක ඇති සියලුම සිදුවීම් ප්‍රතිස්ථාපනය කරන්නේ කෙසේද?


4385

මට මෙම නූල ඇත:

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

කිරීම:

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

පෙනෙන ආකාරයට abcඉහත නූලෙහි පළමු සිදුවීම පමණක් ඉවත් කරයි .

එහි සියලු සිදුවීම් ප්‍රතිස්ථාපනය කරන්නේ කෙසේද ?


5
විට සියලු සිදුවීම් වෙනුවට abaදී ababaඇති ca, ඔබ කරන ප්රතිඵලයක් බලාපොරොත්තු වන්නේ? caba? abca? cca?
රිනියර්පොස්ට්

String.prototype.replaceAll()සෆාරි 13.1 හි නැව්ගත කර ඇති අතර එය දැන් ෆයර්ෆොක්ස් නයිට්ලි සහ ක්‍රෝම් දේව් සහ කැනරි වල ඇති අතර එය ෆයර්ෆොක්ස් 77 සහ ක්‍රෝම් 85 හි නැව්ගත කරනු ඇත. එය තවමත් එම්ඩීඑන් හි ලේඛනගත කර නැත, නමුත් github.com/tc39/proposal-string-replaceall#high-level-api ක explainer ඇත: "නම් searchValue වැලක් වන අතර, String.prototype.replaceAllවිස්ථාපනය සියලු ම සිදුවීම් searchValue (නම් .split(searchValue).join(replaceValue)ගෝලීය සහ නිසි-පලා ප්රකාශන භාවිතා කර ඇත හෝ). නම් searchValue a-ගෝලීය නොවන නිත්ය ප්රකාශනයකි, String.prototype.replaceAllව්යතිරේකයක් අවුලට "
sideshowbarker

Answers:


1613

සටහන: කාර්ය සාධන විවේචනාත්මක කේතයේදී මෙය භාවිතා නොකරන්න.

සරල වචන මාලාවක් සඳහා සාමාන්‍ය ප්‍රකාශන සඳහා විකල්පයක් ලෙස, ඔබට භාවිතා කළ හැකිය

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 ක්‍රමය භාවිතා කරන්න. නමුත් බොහෝ සාමාන්‍ය භාවිත අවස්ථා සඳහා, විශේෂ අක්ෂර ගැන කරදර නොවීම වටී.


148
එය මා මවිතයට පත් කළේ, මෙම ක්‍රමය මඟින් තවත් වස්තූන් වෙන් කිරීම, වැඩි කසළ ප්‍රමාණයක් නිර්මාණය කිරීම හා වැඩි කාලයක් ගතවනු ඇතැයි මම අපේක්ෂා කරන නමුත්, මම ඇත්ත වශයෙන්ම බ්‍රව්සරයක පරීක්‍ෂා කළ විට මෙම ක්‍රමය පිළිගත් ප්‍රතිචාරයට වඩා 20% ක් පමණ වේගවත් විය. ඇත්ත වශයෙන්ම ප්‍රති Results ල වෙනස් විය හැකිය.
MgSam

43
මා කුතුහලයෙන් සිටි අතර මෙය සකසා: jsperf.com/replace-all-vs-split-join . අනෙකුත් ජාවාස්ක්‍රිප්ට් එන්ජින් හා සසඳන විට අරා බෙදීමට / සම්බන්ධ වීමට v8 ඉතා පිස්සු බව පෙනේ.
ෆැබි

8
ඉතා හොඳයි - විශේෂ අක්ෂර පසුකර යන විට නරක රෙජෙක්ස් වීමේ හැකියාවෙන් ඔබව බේරා ගනී. වස්තු දේපලක "මෙය සොයාගෙන එය ප්‍රතිස්ථාපනය කිරීම" සඳහා මම සාමාන්‍ය ධජයක් එක් කරමි, නමුත් මට එය ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය නම් සැලකිලිමත් විය. " හෝ "}" සහ මාස 3 කට පසු මම රෙජෙක්ස් භාවිතා කළ බව අමතක විය!
tobriand

9
හා String.prototype ලෙස: String.prototype.replaceAll = function(f,r){return this.split(f).join(r);}. භාවිතය: "My string".replaceAll('st', '');"මගේ මුද්ද" නිෂ්පාදනය කරයි
මැක්‍රෝමන්

8
නිෂ්පාදනයේදී මෙය භාවිතා නොකිරීමට අනතුරු ඇඟවීමට හේතුවක් මා දකින්නේ නැත. ඔබට බහුවිධ සිදුවීම් ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය නිසා එය රීජෙක්ස් වලින් බේරීමට වඩා වැඩි දෙයක් නොවේ, නමුත් මුලින් රීජෙක්ස් අවශ්‍ය නොවේ. මෙම ඊනියා "හැක්" කදිම replaceAllශ්‍රිතයකින් ඔතා , එය වෙනත් ඕනෑම දෙයක් මෙන් කියවිය හැකිය. කාර්ය සාධනය නරක නොවන බැවින්, මෙම විසඳුම වළක්වා ගැනීමට හේතුවක් නැත.
ඔබ

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

අදහස් දැක්වීමට ප්‍රතිචාර වශයෙන්:

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

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

ප්රතිචාර Upvote ක්ලික් කරන්න ගේ අදහස්, ඔබ ඊටත් වඩා එය සරල හැකි:

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

සටහන: නිත්‍ය ප්‍රකාශනවල විශේෂ (මෙටා) අක්ෂර අඩංගු වන අතර, findඑම අක්ෂර වලින් ගැලවීම සඳහා පූර්ව සැකසුම් නොකර ඉහත ශ්‍රිතයේ තර්කයක් අන්ධ ලෙස සම්මත කිරීම භයානක ය . මේ සඳහා ආවරණය වේ මොසිල්ලා සංවර්ධක ජාලය ගේ JavaScript මාර්ගෝපදේශය සාමාන්ය ප්රකාශිත මත ඔවුන් පහත සඳහන් උපයෝගිතා කාර්යය ඉදිරිපත් කොහේද, (මෙම පිළිතුර මුලින්ම ලියන ලද්දේ සිට අවම වශයෙන් දෙවරක් වෙනස් කර ඇති නිසා විය හැකි යාවත්කාලීන කිරීම් සඳහා 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);
}

4
ඔබේම 'ප්‍රතිස්ථාපන' ක්‍රමය ක්‍රියාත්මක නොකර මෙම "කොටුවෙන් පිටත" ඉටු කර ගත හැකි එකම ක්‍රමය නිත්‍ය ප්‍රකාශන වේ. මම ඒවා භාවිතා කිරීම සඳහා පමණක් යෝජනා නොකරමි.
ෂෝන් බ්‍රයිට්

10
මෙම අදහස් දැක්වීමෙන් මෙය මගේම කාර්යයකි: function replaceAll(find, replace,str) { var re = new RegExp(find, 'g'); str = str.replace(re, replace); return str; }
Upvote

47
replaceAllක්‍රියාවට නැංවීමේ ප්‍රධාන අවවාදය නම් findමෙටාචරැක්ටර් අඩංගු නම් එය ක්‍රියා නොකරනු ඇත .
මාටින් එන්ඩර්

1
E සීන්බ්‍රයිට් ඔබ හරි. මම ඔබේ ජාවාස්ක්‍රිප්ට් එක පීඑච්පී කේතයකින් භාවිතා කළ නිසා පැන යාමට අමතර බැක්ස්ලෑෂ් එකක් එක් කිරීමට මට සිදු විය. ෆෙඩල් එකේ ඔබේ කේතය පරිපූර්ණයි. මම පරික්ෂා කළ යුතුව තිබුණි. සමාව ඉල්ලීම jsfiddle.net/7y19xyq8
ඔනිමුෂා


2437

සම්පූර්ණත්වය සඳහා, මෙය කිරීමට මා භාවිතා කළ යුතු ක්‍රමය ගැන සිතා බැලිය යුතුය. මෙම පිටුවෙහි අනෙක් පිළිතුරු යෝජනා කර ඇති පරිදි මෙය කිරීමට මූලික වශයෙන් ක්‍රම දෙකක් තිබේ.

සටහන: පොදුවේ ගත් කල, ජාවාස්ක්‍රිප්ට් හි ඇති මූලාකෘති දීර් ing කිරීම සාමාන්‍යයෙන් නිර්දේශ නොකරයි. නිදර්ශන අරමුණු සඳහා මම නූල් මූලාකෘතියේ දිගුවන් ලෙස සපයමි, 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% මන්දගාමී වේ. සාමාන්‍ය ප්‍රකාශනවල තේරුම මා භාවිතා කළ ලෝරම් ඉප්සම් ආදානය සඳහා දෙගුණයක් වේගවත් ය.

මෙම ක්‍රියාත්මක කිරීම් දෙක එකිනෙකට එරෙහිව ක්‍රියාත්මක වන මෙම මිණුම් ලකුණ බලන්න .


H තෝමස්ලෙඩූක් සහ වෙනත් අය විසින් පහත දැක්වෙන අදහස් දැක්වීමේදී සඳහන් කර ඇති පරිදි, නිත්‍ය ප්‍රකාශනවල විශේෂ අක්ෂරsearch ලෙස වෙන් කර ඇති ඇතැම් අක්ෂර අඩංගු නම් නිත්‍ය ප්‍රකාශන මත පදනම් වූ ක්‍රියාත්මක කිරීම පිළිබඳ ගැටළුවක් ඇතිවිය හැකිය . ක්‍රියාත්මක කිරීම උපකල්පනය කරන්නේ අමතන්නා කලින් නූලෙන් බේරෙනු ඇති බවයි හෝ නිත්‍ය ප්‍රකාශනවල වගුවේ අක්ෂර නොමැතිව ඇති නූල් පමණක් සමත් වනු ඇත (එම්ඩීඑන්) .

එම්ඩීඑන් අපගේ නූල් වලින් ගැලවීම සඳහා ක්‍රියාත්මක කිරීමක් ද සපයයි. මෙයද ප්‍රමිතිගත කර තිබීම සතුටක් RegExp.escape(str), නමුත් අහෝ, එය නොපවතී:

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

කෙසේ වෙතත්, escapeRegExpඅපගේ String.prototype.replaceAllක්‍රියාවට නැංවීම තුළ අපට ඇමතිය හැකිය , කෙසේ වෙතත්, මෙය ක්‍රියාකාරීත්වයට කොතරම් දුරට බලපානු ඇත්දැයි මට විශ්වාස නැත (සියලු අක්ෂරාංක නූල් මෙන් පැන යාම අවශ්‍ය නොවන නූල් සඳහා පවා විය හැකිය).


8
ඇන්ඩ්‍රොයිඩ් 4.1 හි රීජෙක්ස් ක්‍රමය 15% වේගවත් වේ, නමුත් ඔබ සෙවීම සඳහා ප්‍රකාශනයෙන් ගැලවෙන්නේ නැත, එබැවින් මෙම මිණුම් ලකුණ අසම්පූර්ණයි.
andreszs

33
මෙම විසඳුම සමඟ ගැටළුවක් ඇත, ඔබ සෙවුම් නූලෙහි රීජෙක්ස් ප්‍රකාශනයක විශේෂ අක්ෂර අඩංගු බව පෙනේ නම්, ඒවා අර්ථ නිරූපණය කෙරේ. Andy සැන්ඩි යුනයිටවුල්ෆ් පිළිතුර නිර්දේශ කරමි.
තෝමස් ලෙඩක්

2
පළමුවැන්නා මෙය කරනු ඇත: 'bla.bla'.replaceAll ('. ',' _ '); "_______". දෙවැන්න 'bla_bla' කරනු ඇත, එය සාමාන්‍යයෙන් ඔබට කිරීමට අවශ්‍ය දේ වේ.
රොබ්කෝර්

1
H තෝමස්ලෙඩූක් ඔබ සඳහන් කළ ගැටලුව lodash => lodash.com/docs/4.17.5#escapeRegExp
මතෙව් බෙක්

1
ස්වදේශීය වස්තුව දිගු කිරීම නරක අදහසක් වන්නේ මන්දැයි කල්පනා කරන අනාගත නරඹන්නන් සඳහා මෙය මෙහි තැබීම
බෙන් කූපර්

692

gධජ කට්ටලය සමඟ නිත්‍ය ප්‍රකාශනයක් භාවිතා කිරීමෙන් සියල්ල ප්‍රතිස්ථාපනය වේ:

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

මෙහි ද බලන්න


15
මම හිතන්නේ කරුණාවන්තයි, නමුත් ජේඑස් ග්ලෝබල් රීජෙක්ස් යනු බහුවිධ ප්‍රතිස්ථාපන කළ හැකි එකම ක්‍රමයයි.
මයික්

5
හොඳින් තාක්ෂණික, ඔබ තුළින් පුඩුවක් හැකි var sourceText(අවස්ථා ගණන ගණන් numOfInstancesභාවිතා කරමින්) substringහෝ භේදය හා (අනෙක් උපාය මාර්ග අතර) දිග ගණන් වල thatWhichYouWantToReplaceනම් කරන්න for (var i = 0; i < numOfInstances; i++){ sourceText = sourceText.replace('thatWhichYouWantToReplace', '');} හෝ පහසු පමණක් භාවිතා වන අතර, ලූප ( while sourceText.indexOf(thatWhichYouWantToReplace > -1){ sourceText = sourceText.replace(...)) නමුත් ඔබට අවශ්ය වනු ඇත ඇයි මම දකින්නේ නැහැ භාවිතා /gකිරීම එතරම් පහසු සහ බොහෝ විට වඩා කාර්ය සාධනය වන විට එය එසේ කරන්න.
සර්ගෝල්ඩ්

Ar සර්ගෝල්ඩ් ප්‍රතිස්ථාපනය කිරීමෙන් පසුව පවා ඔබ සියලු අවස්ථාවන් ප්‍රතිස්ථාපනය කර ඇති බව සහතික කිරීම සඳහා ඔබට ලූපයක් කිරීමට අවශ්‍ය වනු ඇත. මගේ පිළිතුර පහත දැක්වේ stackoverflow.com/a/26089052/87520
SamGoody

109

පිළිගත් පිළිතුර මත පදනම් වූ නූල් මූලාකෘති ශ්‍රිතයක් මෙන්න:

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/


5
නමුත් රීජෙක්ස් හි විශේෂ අර්ථයන් ඇති හෝ ඊට findසමාන අක්ෂර අඩංගු නම් කුමක් කළ යුතුද? .$
callum

1
allcallum එවැනි අවස්ථාවකදී ඔබට ඔබගේ සොයාගැනීමේ විචල්‍යයෙන් ගැලවීමට සිදුවේ (ඉහත සංස්කරණය බලන්න).
jesal


jesal, මෙය මා මුහුණ දුන් නූල් ආදේශන ගැටලුවකට අපූරු විසඳුමක් වන අතර, එය ජාවාස්ක්‍රිප්ට් හි ඇති නූල්වල “වෙනස් කළ නොහැකි” බව ජය ගනී. මෙම මූලාකෘති ක්‍රියාකාරිත්වය නූල්වල වෙනස් කළ නොහැකි බව ඉක්මවා යන ආකාරය ඔබට හෝ වෙනත් කෙනෙකුට පැහැදිලි කළ හැකිද? මෙය ක්‍රියාත්මක වේ ; මට අවශ්‍ය වන්නේ එය මතු කරන මෙම සහායක ප්‍රශ්නය තේරුම් ගැනීමයි.
ටොම්

1
Om ටොම්: එය කිසිසේත් වෙනස් කළ නොහැකි බව ජය නොගනී: වෙනස් කළ නොහැකි නූලට var str = thisදෙවන සඳහනක් නිර්මාණය කරයි, ඒ සඳහා replaceක්‍රමවේදය යොදන අතර එමඟින් නව වෙනස් කළ නොහැකි නූලක් ලැබේ. මෙම මූලාකෘති කාර්යයන්, නව හා අණුවල පැවැත්ම string ආපසු නොවේ නම්, ඔබ ලිවීමට හැකි විය කැමතියි someStrVar.replaceAll('o', '0');හා someStrVarවෙනස් වනු ඇත. ඒ වෙනුවට, ඔබ ලිවිය යුත්තේ someStrVar = someStrVar.replaceAll('o', '0');<- නැවත වෙනස් කිරීම නව නිශ්චල නූල් රඳවා තබා ගැනීම සඳහා var සැකසීම සඳහා ය . ඒ වටා කිසිම ක්‍රමයක් නැහැ. කොන්සෝලය තුළ උත්සාහ කරන්න:x = 'foobar'; x.replaceAll('o', '0'); x;
එලියාස් වැන් ඔටෙගෙම්

87

යාවත්කාලීන කිරීම:

යාවත්කාලීනයක් සඳහා එය තරමක් ප්‍රමාදයි, නමුත් මම මේ ප්‍රශ්නයට බාධා කළ නිසාත්, මගේ පෙර පිළිතුර මම සතුටු වන එකක් නොවන බවත් දුටුවෙමි. ප්‍රශ්නය එක් වචනයක් ආදේශ කිරීම සම්බන්ධ බැවින්, වචන මායිම් භාවිතා කිරීම ගැන කිසිවෙකු නොසිතයි ( \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"

මූලික වශයෙන්, මෙම ප්‍රශ්නය මෙහි ඇති ප්‍රශ්නයට සමාන වේ: ජාවාස්ක්‍රිප්ට් "" "වෙනුවට" "" ආදේශ

Ike මයික්, මම එහි දී දුන් පිළිතුර පරීක්ෂා කරන්න ... ග්‍රාහකයේ බහු සිදුවීම් ප්‍රතිස්ථාපනය කිරීමට ඇති එකම ක්‍රමය රීජෙක්ස්ප් නොවේ. නම්‍යශීලී ලෙස සිතන්න, බෙදීම් සිතන්න!

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

විකල්පයක් ලෙස, වචන කොටස් ප්‍රතිස්ථාපනය වීම වැළැක්වීම සඳහා - අනුමත පිළිතුර ද කරනු ඇත! නිතිපතා ප්‍රකාශන භාවිතයෙන් ඔබට මෙම ගැටළුව මඟහරවා ගත හැකිය, එය තරමක් සංකීර්ණ හා එහි ප්‍රති shot ලයක් ලෙස, මන්දගාමී වේ:

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, 'බළලා' කොන්දේසි සහිතව පමණක් ප්‍රතිස්ථාපනය කරන රීජෙක්ස් ය. (එනම් වචනයේ කොටසක් නොවේ), එසේ:

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

මම හිතන්නේ අතිරේක රසවත් කොටස පතුලේ තැබිය යුතුයි. ps: පළමු පේළියේ අඩක් ප්‍රදේශයෙන් පිටත ඇති බව මම දැන් දුටුවෙමි, එය නිවැරදි කිරීමට මට ඉඩ දෙන්න!

69

ගෝලීය නිත්‍ය ප්‍රකාශනයකට ගැලපීම:

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

60

තනි කාල භාවිතය වෙනුවට:

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

කිහිප වතාවක් ආදේශ කිරීම සඳහා භාවිතා කරන්න:

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

යමෙකුට replace n ආදේශ කිරීමට අවශ්‍ය නම්, ඔබට එය එසේ කළ හැකිය:replace(/\n/g, '<br/>')
Phan Van Linh

58

මේවා වඩාත් සුලභ හා කියවිය හැකි ක්‍රම වේ.

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

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

නැතහොත් ප්‍රතිස්ථාපන සියලු ශ්‍රිතය මෙතැනින් උත්සාහ කරන්න:

සාදන ලද වස්තූන් විස්තාරණය කරන ප්‍රයෝජනවත් ජාවාස්ක්‍රිප්ට් ක්‍රම මොනවාද?

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'

2
මූලාකෘති භාවිතා නොකරන අය සඳහා ප්‍රතිස්ථාපන සියලු () ශ්‍රිතය නැවත ලිවිය හැකිද?
Upvote

Up ක්ලික් කරන්න .... ඔබ මූලාකෘති භාවිතා කරයි, එය සියලු JS වස්තු වල කොටසකි. මම හිතන්නේ ඔබ JS පුස්තකාලය prototype.js ගැන සිතනවා.
seth

seth, ටිකක් නිවැරදි කිරීම. ඔබ මූලාකෘතියකට ක්‍රමයක් එකතු කරන්නේ නම්, එය එම වර්ගයේ සියලුම වස්තු සඳහා ලබා ගත හැකිය. ReplceAll ක්‍රමය String මූලාකෘතියට එකතු කරන ලද අතර එය සියලු නූල් වස්තු සඳහා ක්‍රියා කළ යුතුය.
SolutionYogi

olutionsolutionyogi - ඔව්, මම මීට පෙර මූලාකෘති භාවිතා කර ඇත (නිවැරදිව). මම Prototype.js (සමහර විට වැරදියට?) යන්නෙන් අදහස් කරන "මූලාකෘති භාවිතා නොකිරීම" පිළිබඳ OP හි අදහස් දැක්වීමක් කරමින් සිටියෙමි. ජාවාස්ක්‍රිප්ට් වස්තූන්ට මූලාකෘතියක් ඇති බව පැවසීමට උත්සාහ කරන විට මට "මූලාකෘතියක්" පැවසිය යුතුව තිබුණි. මේ අනුව, OP දැනටමත් "වක්‍ර" ආකාරයකින් වුවද, මූලාකෘති භාවිතා කරමින් සිටියේය. වක්‍රව මෙහි භාවිතා කිරීම වැරදි යෙදුම විය හැකි නමුත් මට මහන්සියි.
seth

41

භාවිතා 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', '');

නමුත් මා කලින් සඳහන් කළ පරිදි, එය ලිවිය යුතු රේඛා හෝ කාර්ය සාධනය අනුව විශාල වෙනසක් සිදු නොකරනු ඇත, ශ්‍රිතය හැඹිලි කිරීමෙන් පමණක් දිගු නූල් මත වේගවත් ක්‍රියාකාරිත්වයක් ඇති කළ හැකි අතර ඔබට නැවත භාවිතා කිරීමට අවශ්‍ය නම් ඩ්‍රයි කේතයේ හොඳ පුහුණුවක් ද ඇත.


40

සියලුම '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

නූල් මූලාකෘතිය වෙනස් කිරීමට වඩා සරල දෙයක් ගැන සිතීමට මම උත්සාහ කළෙමි.


1
සරල, පහසු සහ බොහෝ විට වඩාත්ම ක්‍රියාකාරී විකල්පය: හොඳ පිළිතුරකි.
machineghost

ඇත්ත වශයෙන්ම, මම එය පෞද්ගලිකව මෙට්‍රික් සංස්කරණය කර නොමැති අතර, බෙදීම / සම්බන්ධ වීම සාමාන්‍යයෙන් ඉතා ක්‍රියාකාරී විසඳුමකි.
මැෂින් හොස්ට්

1
එය ක්‍රෝම් වල පවා, ෆයර්ෆොක්ස් මත 100% වේගවත්, සහ අයිඊ මත 50% මන්දගාමී වේ ...: jsperf.com/replace-regex-split-join
ඔලිවියර්


32

තනි මිල ගණන් ආදේශ කිරීම:

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

    return text;
}

2
නූල් ආදේශ කිරීම සඳහා දෙවන පේළිය වෙනස් කරන්නේ කෙසේද? මෙය ක්‍රියා නොකරයි: text = text.replace ('ඒයි', 'හෙලෝ'); කිසියම් අදහසක් තිබේද?
ස්ටෙෆාන් Đorđević

2
ෂුවර් ස්ටෙෆාන්, මෙන්න කේතය ... text = text.replace (/ hey / g, 'hello');
ක්‍රිස් රොසෙට්

26

// සංඛ්‍යා සිදුවීම් 0 වන තෙක් එය ලූප කරන්න. නැතහොත් පිටපත් කරන්න / අලවන්න

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

23
මෙම ක්රමය භයානක ය, එය භාවිතා නොකරන්න. ආදේශන නූලෙහි සෙවුම් පදය අඩංගු වේ නම්, අසීමිත පුඩුවක් සිදුවනු ඇත. අවම වශයෙන්, .indexOfවිචල්‍යයක ප්‍රති result ලය ගබඩා කර , මෙම විචල්‍යය දෙවන පරාමිතිය ලෙස භාවිතා කරන්න .indexOf(යතුරුපදයේ us ණ දිග, ප්‍රතිස්ථාපන නූල් වල දිග).
රොබ් ඩබ්ලිව්

මම මුලින්ම සෙවුම් රටාව වෙහෙසට පත් යුනිකෝඩ් වරහනකින් ප්‍රතිස්ථාපනය කිරීම ගැන සිතමින් සිටිමි, එය ආදාන නූලෙහි භාවිතා නොවන බව අපට විශ්වාසයි. පුද්ගලික ප්‍රදේශයේ U + E000 වගේ. ඉන්පසු එය නැවත ඉලක්කයට ආදේශ කරන්න. මම ඒක මෙතන හදලා තියෙනවා. . එය හොඳ අදහසක් දැයි මට විශ්වාස නැත.
Lux

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

ඉහත පිළිතුරු වලට වඩා මට වඩා හොඳින් වැඩ කළා. එම නිසා ( ) පා text new RegExp("abc", 'g')යේ සියලුම සිදුවීම් ( 'g'ධජය) හා ගැලපෙන RegExp නිර්මාණය කරයි "abc". දෙවන කොටස ඔබේ නඩුවේ හිස් නූල ( "") වෙනුවට ආදේශ වේ . strප්‍රති string ලය ලැබෙන ප්‍රති as ලයක් ලෙස අප එය replace(...)අභිබවා යා යුතුය. සමහර අවස්ථාවල ඔබට එය භාවිතා කිරීමට අවශ්‍ය විය හැකිය.


මෙම කේත ස්නිපටය විසඳුම විය හැකි අතර, පැහැදිලි කිරීමක් ඇතුළුව ඔබේ තනතුරේ ගුණාත්මකභාවය වැඩි දියුණු කිරීමට සැබවින්ම උපකාරී වේ. අනාගතයේ දී ඔබ පා readers කයන් සඳහා වන ප්‍රශ්නයට පිළිතුරු සපයන බව මතක තබා ගන්න, ඔබේ කේත යෝජනාවට හේතු එම පුද්ගලයින් නොදැන සිටිය හැකිය.
yivi

ඔව්, ඔබ නිවැරදි. එකතු කරන ලදි. මුල් ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා එය සංස්කරණය කරන ලදි :)
csomakk

සටහන: රීජෙක්ස් හි g ධජය යනු එය සියලු අවස්ථාවන්ට ගැලපෙන ගෝලීය ධජයයි
firstpostcommenter

25

මේ වන වේගයෙන්ම බව අනුවාදය සාමාන්ය ප්රකාශනයක භාවිතා නොකරන .

සංශෝධිත 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, 2017: මෑතකදී නිකුත් කළ ක්‍රෝම් 59 හි වේගවත්ම ක්‍රියාකාරිත්වය රෙජීඑක්ස් දැන් ඇති බව පෙනේ.

මම ඔබේ විසඳුමට ආදරය කළෙමි ... මම ඔබට +10 ලබා දිය හැකි යැයි සිතමි, නමුත් මෙන්න මගේ +1. එම අසීමිත ලූප ගැටළුව මඟහරවා ගැනීම සඳහා ඔබට ප්‍රතිස්ථාපනය කළ උප නූලෙහි දර්ශකය ගබඩා කර අඩු දර්ශකයකට ගැලපීමක් හමු වුවහොත් ඊළඟට පනින්න. කාර්ය සාධනය ගැන මට අදහස් දැක්විය නොහැක, මන්ද මම එය පරීක්‍ෂා නොකළ නමුත් එය මෙම විශිෂ්ටත්වයේ මගේ ශත 2 ක් පමණි.
Fr0zenFyr

om fr0zenfyr ඔබට මඟ හැරී ඇත්දැයි පරීක්ෂා කිරීමට අවශ්‍ය නම් (අසීමිත පුඩුවක් වළක්වා ගැනීම සඳහා) ඔබට නොගැලපීම වැනි කොන්දේසියක් කළ හැකිය if(place.replace(omit) === omit) {, එබැවින් ප්‍රතිස්ථාපන ලූප ගැලපීම භාවිතා කිරීම ආරක්ෂිත බැවින් } else {බෙදීම හා සම්බන්ධ වීම වැනි විවිධ ක්‍රම භාවිතා කරන්න}
කෝල් ලෝරන්ස්

හ්ම් .. නමුත් විසඳුම් දෙකක් ඒකාබද්ධ කිරීමේ තේරුම කුමක්ද? මම කෙසේ හෝ බෙදීම් / සම්බන්ධ වීමේ ප්‍රවේශයේ රසිකයෙක්
නොවෙමි

R Fr0zenFyr මම විශ්වාස කරන්නේ විසඳුම් දෙක ඒකාබද්ධ කිරීමේ අරමුණ ඔබට වේගවත් එකක් භාවිතා කළ නොහැකි නම් මන්දගාමී ක්‍රමවේදයක් අනුගමනය කිරීමයි (උදාහරණයක් ලෙස ලූපය අසීමිත වන විට). එබැවින් එය කාර්යක්ෂමතාවයෙන් යුතුව ක්‍රියාකාරීත්වය සහතික කිරීම සඳහා ආරක්ෂිත ආරක්ෂකයින් වනු ඇත, නමුත් අසමත් වීමේ හැකියාවක් නොමැතිව.
කෝල් ලෝරන්ස්

om මෝමෝ කොතරම් දෝෂ සහිතද?
සැන්ඩ්රොක්

24

කාර්ය සාධනය

අද මම 27.12.2019 තෝරාගත් විසඳුම් සඳහා macOS v10.13.6 (High Sierra) පිළිබඳ පරීක්ෂණ සිදු කරමි .

නිගමන

  • මෙම str.replace(/abc/g, '');( සී ) සියලු නූල් සඳහා හොඳ හරස් වෙබ් බ්රව්සරය වේගයෙන් විසඳුම.
  • split-join( A, B ) හෝ replace( C, D මත පදනම් වූ විසඳුම් ) වේගවත් ය
  • while( E, F, G, H මත පදනම් වූ විසඳුම් ) මන්දගාමී වේ - සාමාන්‍යයෙන් කුඩා නූල් සඳහා ~ 4 ගුණයක් මන්දගාමී වන අතර දිගු නූල් සඳහා ~ 3000 ගුණයක් (!) මන්දගාමී වේ
  • පුනරාවර්තන විසඳුම් ( RA, RB ) මන්දගාමී වන අතර දිගු නූල් සඳහා ක්‍රියා නොකරයි

මමත් මගේම විසඳුමක් නිර්මාණය කරමි. එය දැනට ප්‍රශ්න කාර්යය කරන කෙටිම එක බව පෙනේ:

str.split`abc`.join``

විස්තර

ක්‍රෝම් 79.0, සෆාරි 13.0.4 සහ ෆයර්ෆොක්ස් 71.0 (බිට් 64) මත පරීක්ෂණ සිදු කරන ලදී. පරීක්ෂණ RAසහ RBභාවිත පුනරාවර්තනය. ප්රතිපල

රූප විස්තරය මෙහි ඇතුළත් කරන්න

කෙටි නූල - අක්ෂර 55 යි

ඔබේ යන්ත්‍රය මත පරීක්ෂණ ක්‍රියාත්මක කළ හැකිය මෙතැන . Chrome සඳහා ප්‍රති Results ල:

රූප විස්තරය මෙහි ඇතුළත් කරන්න

දිගු නූල්: අක්ෂර 275 000

පුනරාවර්තන විසඳුම් RA සහ RB ලබා දෙයි

පරාසය දෝෂය: උපරිම ඇමතුම් තොගයේ ප්‍රමාණය ඉක්මවා ඇත

1M අක්ෂර සඳහා ඔවුන් Chrome පවා බිඳ දමයි

රූප විස්තරය මෙහි ඇතුළත් කරන්න

වෙනත් විසඳුම් සඳහා 1M අක්ෂර සඳහා පරීක්ෂණ සිදු කිරීමට මම උත්සාහ කරමි, නමුත් ඊ, එෆ්, ජී, එච් සඳහා බොහෝ කාලයක් ගත වන අතර බ්‍රව්සරය ස්ක්‍රිප්ට් බිඳ දැමීමට ඉල්ලා සිටින නිසා මම පරීක්ෂණ වචන 275K අක්ෂර දක්වා අඩු කරමි. ඔබේ යන්ත්‍රය මත පරීක්ෂණ ක්‍රියාත්මක කළ හැකිය මෙතැන . Chrome සඳහා ප්‍රති Results ල

රූප විස්තරය මෙහි ඇතුළත් කරන්න

පරීක්ෂණ සඳහා භාවිතා කරන කේතය


1
දැන් මෙය ගැඹුරු පිළිතුරක එක් නිරයක්! බොහොම ස්තූතියි! කෙසේ වෙතත්, මට කුතුහලයක් ඇති වන්නේ "නව RegExp (...)" වාක්‍ය ඛණ්ඩය එතරම් දියුණුවක් ලබා දෙන්නේ මන්ද යන්නයි.
මාක් ගර්ජලි ඩොලින්කා

21

ඔබට සොයා ගැනීමට අවශ්‍ය දේ දැනටමත් නූලක තිබේ නම් සහ ඔබට රිජෙක්ස් එස්කැපර් පහසු නැත නම්, ඔබට සම්බන්ධ වීමට / බෙදීමට භාවිතා කළ හැකිය:

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

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


ස්තූතියි! මෙම විසඳුම මගේ ගැටලුව සඳහා හොඳින් ක්‍රියාත්මක වේ :)
xero399

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

එය කොතරම් හොඳින් ක්‍රියාත්මක වේදැයි මම කල්පනා කරමි ... උපස්ථරය ස්වදේශීය හෝ නව අක්ෂර නිර්මාණය කිරීම සඳහා වර්‍ග අරා හරහා ගමන් කරයි.
mmm

16

මම මෙම ක්‍රමයට කැමතියි (එය ටිකක් පිරිසිදු බව පෙනේ):

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

1
හරි, රෙජෙක්ස් රටාවක් ලෙස භාවිතා කිරීම සඳහා ඔබ නූලෙන් බේරෙන්නේ කෙසේද?
rakslice

මම එය සරල පෙළ සඳහා භාවිතා කරමි
ඕවන්

15

කිසිදු රීජෙක්ස් භාවිතා නොකර මේ සඳහා ඇති සරලම ක්‍රමය බෙදී ඇති අතර මෙහි කේතය මෙන් සම්බන්ධ වන්න:

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


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

13

නූලට සමාන රටාවක් තිබේ නම් abccc, ඔබට මෙය භාවිතා කළ හැකිය:

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

13

පෙර පිළිතුරු ඉතා සංකීර්ණ ය. ප්‍රතිස්ථාපන ශ්‍රිතය මේ ආකාරයට භාවිතා කරන්න:

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


10

ප්‍රතිස්ථාපනය කිරීමෙන් පසුව පවා ඔබ සොයන නූල නොපවතින බව සහතික කිරීමට ඔබ උත්සාහ කරන්නේ නම්, ඔබට ලූපයක් භාවිතා කළ යුතුය.

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

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

නමුත් එය එක් එක් චක්‍රයට දෙවරක් ප්‍රතිස්ථාපනය කරයි. තරමක් කාර්යක්ෂම නමුත් අඩු කියවිය හැකි ආකාරයකට ඒකාබද්ධ කළ හැකි සමහර විට (ඡන්දය ප්‍රකාශ කිරීමේ අවදානමක):

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

අනුපිටපත් නූල් සොයන විට මෙය විශේෂයෙන් ප්‍රයෝජනවත් වේ.
උදාහරණයක් ලෙස, අපට 'a ,,, b' තිබේ නම් සහ සියලු අනුපිටපත් කොමාව ඉවත් කිරීමට අපි කැමැත්තෙමු.
.


10

මිනිසුන් රීජෙක්ස් භාවිතය ගැන සඳහන් කර ඇතත්, පා of යේ නඩුව නොසලකා පෙළ ප්‍රතිස්ථාපනය කිරීමට ඔබට අවශ්‍ය නම් වඩා හොඳ ප්‍රවේශයක් ඇත. ලොකු අකුරක් හෝ සිම්පල් එකක් වගේ. පහත සින්ටැක්ස් භාවිතා කරන්න

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

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

ඔබට සවිස්තරාත්මක උදාහරණය මෙතැනින් යොමු කළ හැකිය .


උදාහරණ වෙබ් අඩවියෙන්: "/ toBeReplacedString / gi යනු ඔබ භාවිතා කළ යුතු ප්‍රතිමූර්තියයි. මෙහි g යනු ගෝලීය ගැලපීම සඳහා නිරූපණය කරන අතර මම නිරූපණය කරන්නේ සංවේදී නොවන බවයි. පෙරනිමියෙන්
රීජෙක්ස්

8

ඔබට සරලවම පහත ක්‍රමය භාවිතා කළ හැකිය

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

එකතු කරන්න /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 ගෝලීය යන්නයි

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.