मैं जावास्क्रिप्ट में PHP के preg_match_all () के समान regex के साथ कई घटनाओं का मिलान कैसे कर सकता हूं?

Question

मैं url- एन्कोडेड स्ट्रिंग्स को पार्स करने का प्रयास कर रहा हूं जो कि &या तो अलग किए गए कुंजी = मूल्य जोड़े से बना है &।

निम्नलिखित केवल पहली घटना से मेल खाएगा, अलग-अलग परिणाम तत्वों में कुंजियों और मूल्यों को तोड़कर:

var result = mystring.match(/(?:&|&)?([^=]+)=([^&]+)/)

स्ट्रिंग '1111342 = एडम% 20Franco & 348572 = बॉब% 20Jones' के परिणाम इस प्रकार होंगे:

['1111342', 'Adam%20Franco']

वैश्विक ध्वज का उपयोग करते हुए, 'g', सभी घटनाओं से मेल खाएगा, लेकिन केवल पूरी तरह से मिलान किए गए उप-स्ट्रिंग्स को लौटाएगा, न कि अलग-अलग कुंजियों और मूल्यों को:

var result = mystring.match(/(?:&|&)?([^=]+)=([^&]+)/g)

स्ट्रिंग '1111342 = एडम% 20Franco & 348572 = बॉब% 20Jones' के परिणाम इस प्रकार होंगे:

['1111342=Adam%20Franco', '&348572=Bob%20Jones']

हालांकि मैं स्ट्रिंग को &अलग-अलग विभाजित कर सकता हूं और प्रत्येक कुंजी / मूल्य जोड़ी को अलग-अलग तोड़ सकता हूं , क्या /(?:&|&)?([^=]+)=([^&]+)/PHP के preg_match_all()फ़ंक्शन के समान पैटर्न की कई घटनाओं से मेल खाने के लिए जावास्क्रिप्ट की नियमित अभिव्यक्ति समर्थन का उपयोग करने का कोई तरीका है ?

मैं उप-मैचों के साथ परिणाम प्राप्त करने के लिए किसी तरह लक्ष्य कर रहा हूं जैसे:

[['1111342', '348572'], ['Adam%20Franco', 'Bob%20Jones']]

या

[['1111342', 'Adam%20Franco'], ['348572', 'Bob%20Jones']]

Comments

यह थोड़ा अजीब है कि किसी ने भी replaceयहां उपयोग करने की सिफारिश नहीं की है। var data = {}; mystring.replace(/(?:&|&)?([^=]+)=([^&]+)/g, function(a,b,c,d) { data[c] = d; });किया हुआ। जावास्क्रिप्ट में "matchAll" एक स्ट्रिंग के बजाय एक प्रतिस्थापन हैंडलर फ़ंक्शन के साथ "प्रतिस्थापित" है।

— माइक 'पोमैक्स' कमरमन्स

ध्यान दें कि 2020 में इस प्रश्न को खोजने वाले लोगों के लिए, इसका उत्तर है "regex का उपयोग न करें, URLSearchParams का उपयोग करें , जो आपके लिए यह सब करता है।"

— माइक 'पोमैक्स' कमेरमन्स

Answer 1

टिप्पणियों से लहराया

2020 टिप्पणी: रेगेक्स का उपयोग करने के बजाय, हमारे पास अब है URLSearchParams, जो हमारे लिए यह सब करता है, इसलिए कोई कस्टम कोड, अकेले रेगेक्स, अब और आवश्यक नहीं हैं।

- माइक 'पोमैक्स' कमेरमेंस

ब्राउज़र समर्थन यहां सूचीबद्ध है https://caniuse.com/#feat=urlsearchparams

---

मैं एक वैकल्पिक रेगेक्स सुझाऊंगा, उप-समूहों का उपयोग करके व्यक्तिगत रूप से मापदंडों के नाम और मूल्य पर कब्जा करने के लिए और re.exec():

function getUrlParams(url) {
  var re = /(?:\?|&(?:amp;)?)([^=&#]+)(?:=?([^&#]*))/g,
      match, params = {},
      decode = function (s) {return decodeURIComponent(s.replace(/\+/g, " "));};

  if (typeof url == "undefined") url = document.location.href;

  while (match = re.exec(url)) {
    params[decode(match[1])] = decode(match[2]);
  }
  return params;
}

var result = getUrlParams("http://maps.google.de/maps?f=q&source=s_q&hl=de&geocode=&q=Frankfurt+am+Main&sll=50.106047,8.679886&sspn=0.370369,0.833588&ie=UTF8&ll=50.116616,8.680573&spn=0.35972,0.833588&z=11&iwloc=addr");

result एक वस्तु है:

{
  f: "q"
  जियोकोड: ""
  hl: "de"
  अर्थात्: "UTF8"
  iwloc: "addr"
  ll: "50.116616,8.680573"
  q: "फ्रैंकफर्ट एम मेन"
  sll: "50.106047,8.679886"
  स्रोत: "s_q"
  spn: "0.35972,0.833588"
  sspn: "0.370369,0.833588"
  z: "11"
}

रेगेक्स निम्नानुसार टूट जाता है:

(?: # गैर-कब्जा समूह
  \ \ | & # "?" या "और"
  (: Amp;?)? # (गलत तरीके से HTML एन्कोड किए गए URL के लिए "& amp;" अनुमति दें)
) # अंत गैर-कैप्चरिंग समूह
( # समूह 1
  [^ = & #] + # कोई भी चरित्र "=", "&" या "#" को छोड़कर; कम से कम एक बार
) # अंत समूह 1 - यह पैरामीटर का नाम होगा
(?: # गैर-कब्जा समूह
  =? # एक "=", वैकल्पिक
  ( # समूह 2
    [^ & #] * # किसी भी चरित्र को छोड़कर "&" या "#"; कितनी भी बार
  ) # अंत समूह 2 - यह पैरामीटर्स का मान होगा
) # अंत गैर-कैप्चरिंग समूह

Comments

यह वही है जिसकी मैं उम्मीद कर रहा था। मैंने जावास्क्रिप्ट डॉक्यूमेंटेशन में कभी नहीं देखा है कि उल्लेख किया गया है कि निष्पादन () विधि अगले परिणाम सेट को वापस लौटाएगी यदि एक से अधिक बार कॉल किया जाता है। महान टिप के लिए फिर से धन्यवाद!

— एडम फ्रैंको

यह इस वजह से करता है: regular-expressions.info/javascript.html (इसके माध्यम से पढ़ें: "जावास्क्रिप्ट RegExp ऑब्जेक्ट का उपयोग कैसे करें")

— टॉमालक

इस कोड में एक बग है: "जबकि" के बाद अर्धविराम को हटा दिया जाना चाहिए।

— Jan Willem B

क्योंकि मैं आम तौर पर केवल सामान्य (यानी कैप्चरिंग) समूहों का उपयोग करता हूं अगर मैं वास्तव में उनकी सामग्री में रुचि रखता हूं।

— टॉमालक

@KnightYoshi हाँ। जावास्क्रिप्ट में कोई भी अभिव्यक्ति अपना स्वयं का परिणाम उत्पन्न करती है (जैसे x = yकि असाइन yकरना xऔर उत्पादन करना भी होगा y)। जब हम उस ज्ञान को लागू करते हैं if (match = re.exec(url)): यह A) असाइनमेंट करता है और B) का परिणाम देता re.exec(url)है while। अब अगर कोई मैच नहीं है, जो कि एक मिथ्या मूल्य है, तो re.execलौटाता nullहै। इसलिए जब तक कोई मैच होगा तब तक लूप जारी रहेगा।

— तोमलक

Answer 2

आपको वैश्विक खोज के लिए 'g' स्विच का उपयोग करने की आवश्यकता है

var result = mystring.match(/(&|&)?([^=]+)=([^&]+)/g)

Comments

यह वास्तव में समस्या को हल नहीं करता है: "वैश्विक ध्वज का उपयोग करना, 'जी', सभी घटनाओं से मेल खाएगा, लेकिन केवल पूरी तरह से मिलान किए गए उप-स्ट्रिंग्स को लौटाएं, न कि अलग-अलग कुंजी और मान।"

— एडम फ्रेंको

Answer 3

2020 संपादित करें

URLSearchParams का उपयोग करें , क्योंकि इस कार्य के लिए अब किसी प्रकार के कस्टम कोड की आवश्यकता नहीं है। एक निर्माणकर्ता के साथ ब्राउजर आपके लिए यह कर सकता है:

const str = "1111342=Adam%20Franco&348572=Bob%20Jones";
const data = new URLSearchParams(str);
for (pair of data) console.log(pair)

पैदावार

Array [ "1111342", "Adam Franco" ]
Array [ "348572", "Bob Jones" ]

तो अब इसके लिए regex का उपयोग करने का कोई कारण नहीं है।

मूल उत्तर

यदि आप "ब्लाइंड मैचिंग" पर भरोसा नहीं करना चाहते हैं, जो रनिंग execस्टाइल मैचिंग के साथ आता है , तो जावास्क्रिप्ट मिलान के साथ निर्मित सभी कार्यक्षमता के साथ आता है, लेकिन यह replaceफ़ंक्शन कॉल का हिस्सा है , जब "कैप्चर के साथ क्या करना है" समूह " हैंडलिंग फ़ंक्शन :

var data = {};

var getKeyValue = function(fullPattern, group1, group2, group3) {
  data[group2] = group3;
};

mystring.replace(/(?:&|&)?([^=]+)=([^&]+)/g, getKeyValue);

किया हुआ।

वास्तव में प्रतिस्थापन स्ट्रिंग्स को वापस लेने के लिए कैप्चर ग्रुप हैंडलिंग फंक्शन का उपयोग करने के बजाय (रिप्लेस हैंडलिंग के लिए, पहला आर्ग फुल पैटर्न मैच है, और बाद में आर्ग्स व्यक्तिगत कैप्चर ग्रुप हैं) हम केवल ग्रुप 2 और 3 कैप्चर करते हैं, और उस जोड़ी को कैश करते हैं।

इसलिए, जटिल पार्सिंग फ़ंक्शन लिखने के बजाय, याद रखें कि जावास्क्रिप्ट में "माचिस" फ़ंक्शन केवल एक प्रतिस्थापन हैंडलर फ़ंक्शन के साथ "बदलें" है, और बहुत अधिक पैटर्न मिलान दक्षता हो सकती है।

Comments

मेरे पास एक तार है something "this one" and "that one"। मैं एक सूची में [यानी यह एक, वह एक] के सभी दोहरे उद्धृत तारों को रखना चाहता हूं। अब तक mystring.match(/"(.*?)"/)पहले एक का पता लगाने में ठीक काम करता है, लेकिन मुझे नहीं पता कि एक एकल कैप्चरिंग समूह के लिए अपने समाधान को कैसे अनुकूलित किया जाए।

— नट एवरेस्ट

लगता है कि आपको टिप्पणी में इसे हल करने की कोशिश करने के बजाय, इसके लिए स्टैकओवरफ़्लो पर एक प्रश्न पोस्ट करना चाहिए।

— माइक 'पोमैक्स' कमरमन्स

मैंने एक नया प्रश्न बनाया है: stackoverflow.com/questions/26174122/…

— nu everest

निश्चित नहीं है कि इस उत्तर में इतने अधिक उत्थान क्यों हैं लेकिन यह प्रश्न का सबसे अच्छा उत्तर है।

— कैलिन

Hi @ Mike'Pomax'Kamermans, समुदाय गाइड-लाइनें विशेष रूप से उन्हें सुधारने के लिए प्रविष्टियों को संपादित करने की सलाह देती हैं, देखें: stackoverflow.com/help/behavior । आपके उत्तर का कोर अत्यधिक उपयोगी है, लेकिन मुझे भाषा मिली "याद रखें कि matchAll प्रतिस्थापित है" स्पष्ट नहीं था और यह स्पष्टीकरण नहीं था कि आपका कोड (जो गैर-स्पष्ट है) काम करता है। मुझे लगा कि आपको अच्छी तरह से योग्य प्रतिनिधि मिलना चाहिए, इसलिए मैंने आपके उत्तर को बेहतर पाठ के साथ नकल करने के बजाय संपादित किया। इस प्रश्न के मूल प्रश्नकर्ता के रूप में, यदि आप अभी भी मुझे चाहते हैं, तो इस उत्तर के (और संपादन) की स्वीकृति को वापस पाकर खुश हूँ।

— एडम फ्रैंको

Answer 4

समूहों को कैप्चर करने के लिए, मुझे preg_match_allPHP में उपयोग करने की आदत है और मैंने इसकी कार्यक्षमता को दोहराने की कोशिश की है:

<script>

// Return all pattern matches with captured groups
RegExp.prototype.execAll = function(string) {
    var match = null;
    var matches = new Array();
    while (match = this.exec(string)) {
        var matchArray = [];
        for (i in match) {
            if (parseInt(i) == i) {
                matchArray.push(match[i]);
            }
        }
        matches.push(matchArray);
    }
    return matches;
}

// Example
var someTxt = 'abc123 def456 ghi890';
var results = /[a-z]+(\d+)/g.execAll(someTxt);

// Output
[["abc123", "123"],
 ["def456", "456"],
 ["ghi890", "890"]]

</script>

Comments

@teh_senaus आपको वैश्विक संशोधक को निर्दिष्ट करने की आवश्यकता है /gअन्यथा दौड़ने exec()से वर्तमान सूचकांक नहीं बदलेगा और हमेशा के लिए लूप हो जाएगा।

— अराम कोचरन

अगर मैं इस कोड myRe.test (str) को मान्य करने के लिए कॉल करता हूं और फिर निष्पादित करने का प्रयास करता हूं, तो यह दूसरे मैच में सितारों और हम पहला मैच हार गए।

— fdrv

@fdrv आपको लूप शुरू करने से पहले lastIndex को शून्य पर रीसेट करना होगा: this.lastIndex = 0;

— CF

Answer 5

gवैश्विक मैच के लिए संशोधक सेट करें :

/…/g

Comments

यह वास्तव में समस्या को हल नहीं करता है: "वैश्विक ध्वज का उपयोग करना, 'जी', सभी घटनाओं से मेल खाएगा, लेकिन केवल पूरी तरह से मिलान किए गए उप-स्ट्रिंग्स को लौटाएं, न कि अलग-अलग कुंजी और मान।"

— एडम फ्रेंको

Answer 6

स्रोत:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec

लगातार मिल रहे मैच

यदि आपकी नियमित अभिव्यक्ति "जी" ध्वज का उपयोग करती है, तो आप एक ही स्ट्रिंग में क्रमिक मैचों को खोजने के लिए कई बार निष्पादन () विधि का उपयोग कर सकते हैं। जब आप ऐसा करते हैं, तो खोज नियमित अभिव्यक्ति की अंतिम संपत्ति द्वारा निर्दिष्ट स्ट्रिंग के विकल्प पर शुरू होती है (परीक्षण () भी lastIndex संपत्ति को आगे बढ़ाएगा)। उदाहरण के लिए, मान लें कि आपके पास यह स्क्रिप्ट है:

var myRe = /ab*/g;
var str = 'abbcdefabh';
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
  var msg = 'Found ' + myArray[0] + '. ';
  msg += 'Next match starts at ' + myRe.lastIndex;
  console.log(msg);
}

यह स्क्रिप्ट निम्नलिखित पाठ प्रदर्शित करती है:

Found abb. Next match starts at 3
Found ab. Next match starts at 912

नोट: नियमित अभिव्यक्ति शाब्दिक (या RegExp कंस्ट्रक्टर) को उस स्थिति के भीतर न रखें या जब यह प्रत्येक पुनरावृत्ति पर रीसेट हो जाने वाले LastIndex संपत्ति के कारण मैच हो तो यह एक अनंत लूप बनाएगा। यह भी सुनिश्चित करें कि वैश्विक ध्वज सेट है या लूप यहां भी होगा।

Comments

यदि मैं इस कोड myRe.test (str) को मान्य करने के लिए कॉल करता हूं और फिर ऐसा करने का प्रयास करता हूं, तो यह दूसरे मैच में है और हम पहला मैच हार गए।

— fdrv

आप ध्वज के String.prototype.matchसाथ भी संयोजन कर सकते हैं g: 'abbcdefabh'.match(/ab*/g)रिटर्न['abb', 'ab']

— thom_nic

Answer 7

अगर किसी को (मेरे जैसे) को सरणी समर्थन (यानी एकाधिक चयन) के साथ टॉमालक की विधि की आवश्यकता है, तो यह यहां है:

function getUrlParams(url) {
  var re = /(?:\?|&(?:amp;)?)([^=&#]+)(?:=?([^&#]*))/g,
      match, params = {},
      decode = function (s) {return decodeURIComponent(s.replace(/\+/g, " "));};

  if (typeof url == "undefined") url = document.location.href;

  while (match = re.exec(url)) {
    if( params[decode(match[1])] ) {
        if( typeof params[decode(match[1])] != 'object' ) {
            params[decode(match[1])] = new Array( params[decode(match[1])], decode(match[2]) );
        } else {
            params[decode(match[1])].push(decode(match[2]));
        }
    }
    else
        params[decode(match[1])] = decode(match[2]);
  }
  return params;
}
var urlParams = getUrlParams(location.search);

इनपुट ?my=1&my=2&my=things

परिणाम 1,2,things(पहले केवल लौटा: चीजें)

Answer 8

शीर्षक द्वारा इंगित के रूप में प्रस्तावित प्रश्न के साथ चिपके रहने के लिए, आप वास्तव में प्रत्येक मैच में एक स्ट्रिंग का उपयोग करके पुनरावृति कर सकते हैं String.prototype.replace()। उदाहरण के लिए, निम्नलिखित सिर्फ इतना है कि एक नियमित अभिव्यक्ति के आधार पर सभी शब्दों की एक सरणी प्राप्त करने के लिए:

function getWords(str) {
  var arr = [];
  str.replace(/\w+/g, function(m) {
    arr.push(m);
  });
  return arr;
}

var words = getWords("Where in the world is Carmen Sandiego?");
// > ["Where", "in", "the", "world", "is", "Carmen", "Sandiego"]

अगर मैं कब्जा समूह या यहां तक ​​कि प्रत्येक मैच का सूचकांक प्राप्त करना चाहता था, तो मैं भी ऐसा कर सकता था। निम्नलिखित से पता चलता है कि प्रत्येक मैच को पूरे मैच, 1 कैप्चर ग्रुप और इंडेक्स के साथ कैसे लौटाया जाता है:

function getWords(str) {
  var arr = [];
  str.replace(/\w+(?=(.*))/g, function(m, remaining, index) {
    arr.push({ match: m, remainder: remaining, index: index });
  });
  return arr;
}

var words = getWords("Where in the world is Carmen Sandiego?");

उपरोक्त चलाने के बाद, wordsनिम्नानुसार होगा:

[
  {
    "match": "Where",
    "remainder": " in the world is Carmen Sandiego?",
    "index": 0
  },
  {
    "match": "in",
    "remainder": " the world is Carmen Sandiego?",
    "index": 6
  },
  {
    "match": "the",
    "remainder": " world is Carmen Sandiego?",
    "index": 9
  },
  {
    "match": "world",
    "remainder": " is Carmen Sandiego?",
    "index": 13
  },
  {
    "match": "is",
    "remainder": " Carmen Sandiego?",
    "index": 19
  },
  {
    "match": "Carmen",
    "remainder": " Sandiego?",
    "index": 22
  },
  {
    "match": "Sandiego",
    "remainder": "?",
    "index": 29
  }
]

PHP में जो कुछ भी उपलब्ध है उसके समान कई घटनाओं का मिलान करने के लिए preg_match_allआप इस प्रकार की सोच का उपयोग कर सकते हैं अपने खुद के बनाने या कुछ का उपयोग करने के लिए YourJS.matchAll()। आपका कार्य कमोबेश इस फ़ंक्शन को परिभाषित करता है:

function matchAll(str, rgx) {
  var arr, extras, matches = [];
  str.replace(rgx.global ? rgx : new RegExp(rgx.source, (rgx + '').replace(/[\s\S]+\//g , 'g')), function() {
    matches.push(arr = [].slice.call(arguments));
    extras = arr.splice(-2);
    arr.index = extras[0];
    arr.input = extras[1];
  });
  return matches[0] ? matches : null;
}

Comments

चूँकि आप किसी URL के क्वेरी स्ट्रिंग को पार्स करना चाहते हैं, आप कुछ ऐसा भी उपयोग कर सकते हैं YourJS.parseQS()( yourjs.com/snippets/56 ), हालाँकि बहुत सारे अन्य पुस्तकालय भी इस कार्यक्षमता को प्रदान करते हैं।

— क्रिस वेस्ट

एक लूप में एक बाहरी दायरे से एक चर को संशोधित करना जो प्रतिस्थापन को वापस करने वाला है, एक प्रकार का खराब है। आपका दुरुपयोग यहाँ प्रतिस्थापित

— जुआन मेंडेस

Answer 9

यदि आप इसका उपयोग करके दूर हो सकते हैं तो mapयह चार-पंक्ति-समाधान है:

var mystring = '1111342=Adam%20Franco&348572=Bob%20Jones';

var result = mystring.match(/(&|&)?([^=]+)=([^&]+)/g) || [];
result = result.map(function(i) {
  return i.match(/(&|&)?([^=]+)=([^&]+)/);
});

console.log(result);

सुंदर नहीं है, कुशल नहीं है, लेकिन कम से कम यह कॉम्पैक्ट है। ;)

Answer 10

उपयोग करें window.URL:

> s = 'http://www.example.com/index.html?1111342=Adam%20Franco&348572=Bob%20Jones'
> u = new URL(s)
> Array.from(u.searchParams.entries())
[["1111342", "Adam Franco"], ["348572", "Bob Jones"]]

Answer 11

2020 से Hlllo। मुझे आपके ध्यान में String.prototyp.matchAll () लाने दें :

let regexp = /(?:&|&)?([^=]+)=([^&]+)/g;
let str = '1111342=Adam%20Franco&348572=Bob%20Jones';

for (let match of str.matchAll(regexp)) {
    let [full, key, value] = match;
    console.log(key + ' => ' + value);
}

आउटपुट:

1111342 => Adam%20Franco
348572 => Bob%20Jones

Comments

आखिरकार! सावधानी का एक नोट: "ECMAScript 2020, 11 वें संस्करण, स्ट्रिंग्स के लिए मैचअल विधि का परिचय देता है, वैश्विक नियमित अभिव्यक्ति द्वारा उत्पन्न सभी मैच ऑब्जेक्ट्स के लिए एक पुनरावृत्ति उत्पन्न करने के लिए" । उत्तर में जुड़ी साइट के अनुसार, अधिकांश ब्राउज़र और नोडज वर्तमान में इसका समर्थन करते हैं, लेकिन आईई, सफारी या सैमसंग इंटरनेट नहीं। उम्मीद है कि समर्थन जल्द ही व्यापक होगा, लेकिन YMMV थोड़ी देर के लिए।

— एडम फ्रैंको

Answer 12

एक ही नाम का उपयोग करते हुए कई मापदंडों को पकड़ने के लिए, मैंने टॉमालक की विधि में लूप को इस तरह से संशोधित किया:

  while (match = re.exec(url)) {
    var pName = decode(match[1]);
    var pValue = decode(match[2]);
    params[pName] ? params[pName].push(pValue) : params[pName] = [pValue];
  }

इनपुट: ?firstname=george&lastname=bush&firstname=bill&lastname=clinton

रिटर्न: {firstname : ["george", "bill"], lastname : ["bush", "clinton"]}

Comments

जबकि मुझे आपके विचार पसंद हैं, यह एकल params के साथ अच्छी तरह से काम नहीं करता है, जैसे ?cinema=1234&film=12&film=34मैं उम्मीद करता हूं {cinema: 1234, film: [12, 34]}। इसे दर्शाने के लिए अपने उत्तर को संपादित करें।

— ट्वीस्टरेब जुब

Answer 13

खैर ... मुझे एक समान समस्या थी ... मैं RegExp के साथ एक वृद्धिशील / चरण खोज चाहता हूं (जैसे: खोज शुरू करें ... कुछ प्रसंस्करण करें ... अंतिम मैच तक खोज जारी रखें)

बहुत सारी इंटरनेट खोज के बाद ... हमेशा की तरह (यह अब एक आदत बन गई है) मैं स्टैकओवरफ़्लो में समाप्त हो गया और उत्तर मिला ...

व्हाट्सएप को संदर्भित नहीं किया गया है और उल्लेख करने के लिए मायने रखता है कि " lastIndex" मैं अब समझता हूं कि RegExp ऑब्जेक्ट " lastIndex" संपत्ति को क्यों लागू करता है

Answer 14

इसे विभाजित करना मुझे सबसे अच्छा विकल्प लगता है:

'1111342=Adam%20Franco&348572=Bob%20Jones'.split('&').map(x => x.match(/(?:&|&)?([^=]+)=([^&]+)/))

Answer 15

रेगेक्स नर्क से बचने के लिए आप अपना पहला मैच ढूंढ सकते हैं, एक चंक काट सकते हैं और फिर अगले एक को खोजने की कोशिश करेंगे। C # में यह कुछ इस तरह दिखता है, क्षमा करें मैंने इसे आपके लिए जावास्क्रिप्ट पर पोर्ट नहीं किया है।

        long count = 0;
        var remainder = data;
        Match match = null;
        do
        {
            match = _rgx.Match(remainder);
            if (match.Success)
            {
                count++;
                remainder = remainder.Substring(match.Index + 1, remainder.Length - (match.Index+1));
            }
        } while (match.Success);
        return count;