आप जावास्क्रिप्ट नियमित अभिव्यक्ति में मिलान किए गए समूहों तक कैसे पहुंच सकते हैं?

Question

मैं एक स्ट्रिंग के एक हिस्से को एक नियमित अभिव्यक्ति का उपयोग करके मेल करना चाहता हूं और फिर उस कोष्ठक प्रतिस्थापन को एक्सेस करना चाहता हूं :

var myString = "something format_abc"; // I want "abc"

var arr = /(?:^|\s)format_(.*?)(?:\s|$)/.exec(myString);

console.log(arr);     // Prints: [" format_abc", "abc"] .. so far so good.
console.log(arr[1]);  // Prints: undefined  (???)
console.log(arr[0]);  // Prints: format_undefined (!!!)

मैं क्या गलत कर रहा हूं?

---

मुझे पता चला है कि ऊपर दिए गए नियमित अभिव्यक्ति कोड में कुछ भी गलत नहीं था: वास्तविक स्ट्रिंग जो मैं इसके खिलाफ परीक्षण कर रहा था:

"date format_%A"

यह रिपोर्ट करना कि "% A" अपरिभाषित है, एक बहुत ही अजीब व्यवहार लगता है, लेकिन यह सीधे इस प्रश्न से संबंधित नहीं है, इसलिए मैंने एक नया खोला है, एक मिलान किए गए विकल्प को जावास्क्रिप्ट में "अपरिभाषित" क्यों लौटाया जा रहा है? ।

---

मुद्दा यह था कि console.logइसके मापदंडों को एक printfबयान की तरह लिया जाता है , और चूंकि स्ट्रिंग मैं लॉगिंग ( "%A") में एक विशेष मूल्य था, यह अगले पैरामीटर के मूल्य को खोजने की कोशिश कर रहा था।

Answer 1

आप इस तरह कैप्चरिंग समूहों तक पहुँच सकते हैं:

var myString = "something format_abc";
var myRegexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
var match = myRegexp.exec(myString);
console.log(match[1]); // abc

और अगर कई मैच हैं, तो आप उन पर ध्यान केंद्रित कर सकते हैं:

var myString = "something format_abc";
var myRegexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
match = myRegexp.exec(myString);
while (match != null) {
  // matched text: match[0]
  // match start: match.index
  // capturing group n: match[n]
  console.log(match[0])
  match = myRegexp.exec(myString);
}

संपादित करें: 2019-09-10

जैसा कि आप देख सकते हैं कि कई मैचों पर पुनरावृति करने का तरीका बहुत सहज नहीं था। इससे String.prototype.matchAllविधि का प्रस्ताव होता है । इस नई विधि को ECMAScript 2020 विनिर्देशन में शिप करने की उम्मीद है । यह हमें एक स्वच्छ एपीआई देता है और कई समस्याओं को हल करता है। यह क्रोम 73+ / नोड 12+ और फ़ायरफ़ॉक्स 67+ के रूप में प्रमुख ब्राउज़रों और जेएस इंजनों पर उतरने के लिए शुरू किया गया है ।

विधि एक पुनरावृत्ति देता है और निम्नानुसार उपयोग किया जाता है:

const string = "something format_abc";
const regexp = /(?:^|\s)format_(.*?)(?:\s|$)/g;
const matches = string.matchAll(regexp);
    
for (const match of matches) {
  console.log(match);
  console.log(match.index)
}

जैसा कि यह एक पुनरावृत्ति देता है, हम कह सकते हैं कि यह आलसी है, यह विशेष रूप से बड़ी संख्या में कैप्चरिंग समूहों या बहुत बड़े तारों को संभालते समय उपयोगी है। लेकिन अगर आपको जरूरत है, तो परिणाम आसानी से फैल सिंटैक्स या Array.fromविधि का उपयोग करके एक ऐरे में बदल सकता है :

function getFirstGroup(regexp, str) {
  const array = [...str.matchAll(regexp)];
  return array.map(m => m[1]);
}

// or:
function getFirstGroup(regexp, str) {
  return Array.from(str.matchAll(regexp), m => m[1]);
}

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

साथ ही, विधि के आंतरिक कामकाज सरल हैं। जनरेटर फ़ंक्शन का उपयोग करने वाला एक समान कार्यान्वयन निम्नानुसार होगा:

function* matchAll(str, regexp) {
  const flags = regexp.global ? regexp.flags : regexp.flags + "g";
  const re = new RegExp(regexp, flags);
  let match;
  while (match = re.exec(str)) {
    yield match;
  }
}

मूल regexp की एक प्रति बनाई जाती है; यह lastIndexगुणकों के गुणन के कारण होने वाले दुष्प्रभावों से बचने के लिए होता है, जब वे मल्टीपल मैचों से गुजर रहे होते हैं।

इसके अलावा, हमें यह सुनिश्चित करने की आवश्यकता है कि अनंत लूप से बचने के लिए regexp के पास वैश्विक ध्वज है।

मुझे यह देखकर भी खुशी हुई कि प्रस्ताव के विचार-विमर्श में भी इस StackOverflow प्रश्न को संदर्भित किया गया था ।

Comments

+1 कृपया ध्यान दें कि दूसरे उदाहरण में आपको RegExp ऑब्जेक्ट (न केवल "/ myregexp /") का उपयोग करना चाहिए, क्योंकि यह ऑब्जेक्ट में lastIndex मान रखता है। Regexp ऑब्जेक्ट का उपयोग किए बिना यह असीम रूप से पुनरावृत्त करेगा

— ianaz

@ianaz: मुझे विश्वास नहीं है कि सच है? http://jsfiddle.net/weEg9/ कम से कम क्रोम पर काम करने लगता है।

— कताई

इसके बजाय ऊपर क्यों var match = myString.match(myRegexp); // alert(match[1])?

— जॉन एलेन

स्पष्ट "नए RegExp" के लिए कोई ज़रूरत नहीं है, हालांकि अनंत लूप तब तक होगा जब तक कि / जी निर्दिष्ट नहीं किया जाता है

— जॉर्ज सी

अनंत लूप में नहीं चलने का एक और तरीका है, विस्फोटक तरीके से अपडेट स्ट्रिंग, जैसे string = string.substring(match.index + match[0].length)

— ओल्गा

Answer 2

यहाँ एक विधि है जिसका उपयोग आप प्रत्येक मैच के लिए n वें कैप्चरिंग समूह को प्राप्त करने के लिए कर सकते हैं :

function getMatches(string, regex, index) {
  index || (index = 1); // default to the first capturing group
  var matches = [];
  var match;
  while (match = regex.exec(string)) {
    matches.push(match[index]);
  }
  return matches;
}


// Example :
var myString = 'something format_abc something format_def something format_ghi';
var myRegEx = /(?:^|\s)format_(.*?)(?:\s|$)/g;

// Get an array containing the first capturing group for every match
var matches = getMatches(myString, myRegEx, 1);

// Log results
document.write(matches.length + ' matches found: ' + JSON.stringify(matches))
console.log(matches);

Comments

यह दूसरों के लिए एक बेहतर जवाब है क्योंकि यह केवल एक होने के बजाय सभी मैचों पर सही ढंग से चलना दिखाता है।

— रॉब इवांस

mnn सही है। यह एक अनंत लूप का उत्पादन करेगा यदि 'जी' ध्वज मौजूद नहीं है। इस फ़ंक्शन के साथ बहुत सावधान रहें।

— Druska

मैंने इसे अजगर के re.findall () के समान बनाने के लिए इसमें सुधार किया। यह सभी मैचों को एरे के एक समूह में जोड़ता है। यह वैश्विक संशोधक अनंत लूप समस्या को भी ठीक करता है। jsfiddle.net/ravishi/MbwpV

— 20

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

— दीवारकार

@MichaelMikowski जब आप निष्पादन की सीमा को नहीं मार रहे हैं, तो सार्थक रूप से धीमा नहीं है। जब आप कर रहे हैं, यह स्पष्ट रूप से बहुत धीमी है। मैं कह रहा हूं कि आपका कोड काम नहीं करता है, मैं कह रहा हूं कि व्यवहार में मुझे लगता है कि यह अच्छे से अधिक नुकसान पहुंचाएगा। देव वातावरण में काम करने वाले लोग कोड के कुछ चैंक के 10,000 अनावश्यक निष्पादन करने के बावजूद कोड को बिना किसी लोड के ठीक काम करते देखेंगे। फिर वे इसे एक उत्पादन वातावरण में धकेल देंगे और आश्चर्य करेंगे कि उनका ऐप क्यों लोड के नीचे जाता है। मेरे अनुभव में यह बेहतर है अगर चीजें स्पष्ट रूप से टूटती हैं, और पहले विकास चक्र में।

— दीवारर

Answer 3

var myString = "something format_abc";
var arr = myString.match(/\bformat_(.*?)\b/);
console.log(arr[0] + " " + arr[1]);

यह \bबिल्कुल वैसी बात नहीं है। (यह काम करता है --format_foo/, लेकिन काम नहीं करता है format_a_b) लेकिन मैं आपकी अभिव्यक्ति का विकल्प दिखाना चाहता था, जो ठीक है। बेशक, matchकॉल महत्वपूर्ण बात है।

Comments

बिलकुल उलटा है। '\ b' शब्दों का परिसीमन करता है। शब्द = '\ w' = [a-zA-Z0-9_]। "format_a_b" एक शब्द है।

— बीएफ

@BFHonestly, मैंने कहा "पर काम नहीं करता है format_a_b" के रूप में 6 साल पहले सोचा था, और मुझे याद नहीं है कि मैं वहाँ क्या मतलब है ... :-) मुझे लगता है इसका मतलब है " aकेवल कब्जा करने के लिए काम नहीं करता है ", " अर्थात। के बाद पहला वर्णमाला भाग format_।

— फीलो

मैं यह कहना चाहता था कि \ b (- format_foo /} \ b do not return "--format_foo /" क्योंकि "-" और "/" no \ word वर्ण हैं। लेकिन \ b (format_a_b) \ b वापस लौटते हैं - format_a_b। "ठीक है? मैं आपके पाठ विवरण का उल्लेख राउंड ब्रैकेट में करता हूं। (क्या नीचे वोट नहीं है!)

— BF

Answer 4

ऊपर दिए गए मल्टी-मैच कोष्ठकों के उदाहरणों के संबंध में, मैं यहां एक उत्तर की तलाश में था कि मुझे क्या चाहिए।

var matches = mystring.match(/(?:neededToMatchButNotWantedInResult)(matchWanted)/igm);

ऊपर और .push () के साथ थोड़ा जटिल फ़ंक्शन कॉल देखने के बाद, यह मुझ पर dawned कि समस्या को हल करने के साथ बहुत ही सुलझाना किया जा सकता है। , दूसरे पैरामीटर के लिए CLEAN, अंतर्निहित पुनरावर्ती फ़ंक्शन कॉल विकल्प!):

var yourstring = 'something format_abc something format_def something format_ghi';

var matches = [];
yourstring.replace(/format_([^\s]+)/igm, function(m, p1){ matches.push(p1); } );

इसके बाद, मुझे नहीं लगता कि मैं कभी भी .match () का उपयोग करने जा रहा हूं, शायद ही फिर कभी।

Answer 5

अंतिम लेकिन कम से कम, मुझे कोड की एक पंक्ति मिली जो मेरे लिए ठीक काम करती थी (JS ES6):

let reg = /#([\S]+)/igm; // Get hashtags.
let string = 'mi alegría es total! ✌🙌\n#fiestasdefindeaño #PadreHijo #buenosmomentos #france #paris';

let matches = (string.match(reg) || []).map(e => e.replace(reg, '$1'));
console.log(matches);

यह लौटेगा:

['fiestasdefindeaño', 'PadreHijo', 'buenosmomentos', 'france', 'paris']

Comments

बूम! ऐसा इसलिए है सबसे सुरुचिपूर्ण समाधान यहाँ। मुझे यह अलेक्सा द्वारा पूर्ण- दृष्टिकोण की तुलना में बेहतर लगा क्योंकि यह कम-लुक-फार-वाई है और कई परिणामों के लिए अधिक सुरुचिपूर्ण है। इस पर अच्छी नौकरी, सेबस्टियन एच।replace

— कोडी

यह इतनी अच्छी तरह से काम करता है कि निश्चित रूप से मेरे बर्तनों में जा रहा है :)

— कोड़ी

@ कोडी हाहा धन्यवाद आदमी!

— सेबेस्टियन एच।

Answer 6

इस उत्तर में प्रयुक्त शब्दावली

• मैच आपके स्ट्रिंग के खिलाफ अपने RegEx पैटर्न को चलाने के परिणाम को इंगित करता है जैसे someString.match(regexPattern):।
• मिलान किए गए पैटर्न इनपुट स्ट्रिंग के सभी मिलान भागों को दर्शाते हैं, जो सभी मैच सरणी के अंदर रहते हैं । ये इनपुट स्ट्रिंग के अंदर आपके पैटर्न के सभी उदाहरण हैं।
• मिलान किए गए समूह RegEx पैटर्न में परिभाषित किए गए सभी समूहों को पकड़ने का संकेत देते हैं। (कोष्ठक के अंदर के पैटर्न, जैसे:, /format_(.*?)/gजहां (.*?)एक मिलान समूह होगा।) ये मिलान किए गए पैटर्न के भीतर रहते हैं ।

विवरण

मिलान किए गए समूहों तक पहुंचने के लिए , प्रत्येक मिलान किए गए पैटर्न में , आपको मैच पर पुनरावृति के लिए एक फ़ंक्शन या कुछ समान होना चाहिए । ऐसे कई तरीके हैं जिनसे आप ऐसा कर सकते हैं, जैसे कि अन्य उत्तर दिखाते हैं। अधिकांश अन्य उत्तर सभी मिलान किए गए पैटर्न पर पुनरावृति करने के लिए थोड़ी देर के लूप का उपयोग करते हैं , लेकिन मुझे लगता है कि हम सभी उस दृष्टिकोण के साथ संभावित खतरों को जानते हैं। new RegExp()केवल एक पैटर्न के बजाय मैच करना आवश्यक है, जो केवल एक टिप्पणी में उल्लिखित है। ऐसा इसलिए है क्योंकि .exec()विधि एक जनरेटर फ़ंक्शन के समान व्यवहार करती है - यह हर बार मैच होने पर रुकती है , लेकिन .lastIndexअगले .exec()कॉल पर इसे वहां से जारी रखने के लिए रखती है ।

कोड उदाहरण

नीचे एक समारोह का एक उदाहरण है searchStringजो एक रिटर्न Arrayसब से मेल नहीं खाते पैटर्न है, जहां प्रत्येक matchएक है Arrayसभी के साथ युक्त मिलान किया समूहों । थोड़ी देर लूप का उपयोग करने के बजाय, मैंने दोनों Array.prototype.map()फ़ंक्शन के साथ-साथ एक अधिक प्रदर्शन करने वाले तरीके का उपयोग करके उदाहरण प्रदान किए हैं - एक सादे- forलूप का उपयोग करके ।

संक्षिप्त संस्करण (कम कोड, अधिक संश्लिष्ट चीनी)

ये कम प्रदर्शन करने वाले हैं क्योंकि वे मूल रूप forEachसे तेज- forलूप के बजाय एक- लूप को लागू करते हैं ।

// Concise ES6/ES2015 syntax
const searchString = 
    (string, pattern) => 
        string
        .match(new RegExp(pattern.source, pattern.flags))
        .map(match => 
            new RegExp(pattern.source, pattern.flags)
            .exec(match));

// Or if you will, with ES5 syntax
function searchString(string, pattern) {
    return string
        .match(new RegExp(pattern.source, pattern.flags))
        .map(match =>
            new RegExp(pattern.source, pattern.flags)
            .exec(match));
}

let string = "something format_abc",
    pattern = /(?:^|\s)format_(.*?)(?:\s|$)/;

let result = searchString(string, pattern);
// [[" format_abc", "abc"], null]
// The trailing `null` disappears if you add the `global` flag

निष्पादक संस्करण (अधिक कोड, कम संश्लिष्ट चीनी)

// Performant ES6/ES2015 syntax
const searchString = (string, pattern) => {
    let result = [];

    const matches = string.match(new RegExp(pattern.source, pattern.flags));

    for (let i = 0; i < matches.length; i++) {
        result.push(new RegExp(pattern.source, pattern.flags).exec(matches[i]));
    }

    return result;
};

// Same thing, but with ES5 syntax
function searchString(string, pattern) {
    var result = [];

    var matches = string.match(new RegExp(pattern.source, pattern.flags));

    for (var i = 0; i < matches.length; i++) {
        result.push(new RegExp(pattern.source, pattern.flags).exec(matches[i]));
    }

    return result;
}

let string = "something format_abc",
    pattern = /(?:^|\s)format_(.*?)(?:\s|$)/;

let result = searchString(string, pattern);
// [[" format_abc", "abc"], null]
// The trailing `null` disappears if you add the `global` flag

मुझे अभी तक इन विकल्पों की तुलना अन्य उत्तरों में पहले बताए गए लोगों से करनी है, लेकिन मुझे संदेह है कि यह दृष्टिकोण कम प्रदर्शन करने वाला और दूसरों की तुलना में कम विफल-सुरक्षित है।

Answer 7

String#matchAll( चरण 3 ड्राफ्ट / 7 दिसंबर, 2018 प्रस्ताव देखें ), मैच ऑब्जेक्ट में सभी समूहों के लिए अतिरिक्त को सरल करता है (मन कि समूह 0 पूरे मैच है, जबकि आगे समूह पैटर्न में कैप्चरिंग समूहों के अनुरूप हैं):

matchAllउपलब्ध के साथ , आप whileलूप से बच सकते हैं और इसके execसाथ /g... इसके बजाय, उपयोग करने से matchAll, आपको एक पुनरावृत्ति प्राप्त होती है जिसे आप अधिक सुविधाजनक for...of, सरणी प्रसार या Array.from()निर्माण के साथ उपयोग कर सकते हैं।

यह विधि PHP में पायथन में Regex.Matches, C # में एक समान आउटपुट देता है ।re.finditerpreg_match_all

JS डेमो देखें (Google Chrome में परीक्षण किया गया 73.0.3683.67 (आधिकारिक बिल्ड), बीटा (64-बिट)):

var myString = "key1:value1, key2-value2!!@key3=value3";
var matches = myString.matchAll(/(\w+)[:=-](\w+)/g);
console.log([...matches]); // All match with capturing group values

console.log([...matches])शो

आपको उपयोग करके मैच वैल्यू या विशिष्ट समूह मान भी मिल सकते हैं

let matchData = "key1:value1, key2-value2!!@key3=value3".matchAll(/(\w+)[:=-](\w+)/g)
var matches = [...matchData]; // Note matchAll result is not re-iterable

console.log(Array.from(matches, m => m[0])); // All match (Group 0) values
// => [ "key1:value1", "key2-value2", "key3=value3" ]
console.log(Array.from(matches, m => m[1])); // All match (Group 1) values
// => [ "key1", "key2", "key3" ]

नोट : ब्राउज़र संगतता विवरण देखें।

Comments

प्रमुख मूल्य जोड़े के लिए सही उदाहरण। संक्षिप्त और पढ़ने में आसान, उपयोग करने के लिए बहुत सरल। इसके अलावा, बेहतर त्रुटि से निपटने, प्रसार शून्य के बजाय एक खाली सरणी लौटाएगा, इसलिए कोई अधिक 'त्रुटि, शून्य की कोई संपत्ति "लंबाई नहीं है

— जारोद मैक्गुइरे

Answer 8

आपका सिंटैक्स शायद रखने के लिए सबसे अच्छा नहीं है। FF / Gecko फ़ंक्शन के विस्तार के रूप में RegExp को परिभाषित करता है।
(FF2 जहां तक ​​गया typeof(/pattern/) == 'function')

ऐसा लगता है कि यह एफएफ के लिए विशिष्ट है - आईई, ओपेरा, और क्रोम इसके लिए सभी अपवादों को फेंक देते हैं।

इसके बजाय, दूसरों द्वारा पहले बताई गई विधि का उपयोग करें: RegExp#execया String#match।
वे एक ही परिणाम प्रदान करते हैं:

var regex = /(?:^|\s)format_(.*?)(?:\s|$)/;
var input = "something format_abc";

regex(input);        //=> [" format_abc", "abc"]
regex.exec(input);   //=> [" format_abc", "abc"]
input.match(regex);  //=> [" format_abc", "abc"]

Answer 9

execविधि को आह्वान करने की कोई आवश्यकता नहीं है ! आप सीधे स्ट्रिंग पर "मैच" विधि का उपयोग कर सकते हैं। बस कोष्ठक मत भूलना।

var str = "This is cool";
var matches = str.match(/(This is)( cool)$/);
console.log( JSON.stringify(matches) ); // will print ["This is cool","This is"," cool"] or something like that...

स्थिति 0 में सभी परिणामों के साथ एक स्ट्रिंग है। स्थिति 1 में पहले मैच कोष्ठकों द्वारा दर्शाया गया है, और स्थिति 2 का दूसरा मैच आपके कोष्ठकों में अलग-अलग है। नेस्टेड कोष्ठक मुश्किल हैं, इसलिए सावधान रहें!

Comments

वैश्विक ध्वज के बिना यह सभी मैचों को लौटाता है, इसके साथ, आपको केवल एक बड़ा एक मिलेगा ताकि उसके लिए देख सकें।

— Shadymilkman01 22

Answer 10

एक लाइनर जो केवल तभी व्यावहारिक होता है, जब आपके पास एक कोष्ठक की एक जोड़ी हो:

while ( ( match = myRegex.exec( myStr ) ) && matches.push( match[1] ) ) {};

Comments

क्यों नहींwhile (match = myRegex.exec(myStr)) matches.push(match[1])

— विल्मा

Answer 11

अपने कोड का उपयोग करना:

console.log(arr[1]);  // prints: abc
console.log(arr[0]);  // prints:  format_abc

संपादित करें: सफारी 3, अगर यह मायने रखता है।

Answer 12

Es2018 के String.match()साथ अब आप नामित समूहों के साथ, अपने regex को और अधिक स्पष्ट कर सकते हैं कि वह क्या करने की कोशिश कर रहा था।

const url =
  '/programming/432493/how-do-you-access-the-matched-groups-in-a-javascript-regular-expression?some=parameter';
const regex = /(?<protocol>https?):\/\/(?<hostname>[\w-\.]*)\/(?<pathname>[\w-\./]+)\??(?<querystring>.*?)?$/;
const { groups: segments } = url.match(regex);
console.log(segments);

और आपको कुछ मिलेगा

{प्रोटोकॉल: "https", hostname: "stackoverflow.com", pathname: "questions / 432493 / how-do-you-access-the-matched-groups-of-a-javascript-regular-अभिव्यक्ति", querystring: " कुछ = पैरामीटर "}

Answer 13

function getMatches(string, regex, index) {
  index || (index = 1); // default to the first capturing group
  var matches = [];
  var match;
  while (match = regex.exec(string)) {
    matches.push(match[index]);
  }
  return matches;
}


// Example :
var myString = 'Rs.200 is Debited to A/c ...2031 on 02-12-14 20:05:49 (Clear Bal Rs.66248.77) AT ATM. TollFree 1800223344 18001024455 (6am-10pm)';
var myRegEx = /clear bal.+?(\d+\.?\d{2})/gi;

// Get an array containing the first capturing group for every match
var matches = getMatches(myString, myRegEx, 1);

// Log results
document.write(matches.length + ' matches found: ' + JSON.stringify(matches))
console.log(matches);

function getMatches(string, regex, index) {
  index || (index = 1); // default to the first capturing group
  var matches = [];
  var match;
  while (match = regex.exec(string)) {
    matches.push(match[index]);
  }
  return matches;
}


// Example :
var myString = 'something format_abc something format_def something format_ghi';
var myRegEx = /(?:^|\s)format_(.*?)(?:\s|$)/g;

// Get an array containing the first capturing group for every match
var matches = getMatches(myString, myRegEx, 1);

// Log results
document.write(matches.length + ' matches found: ' + JSON.stringify(matches))
console.log(matches);

Answer 14

आपका कोड मेरे लिए काम करता है (FF3 on Mac) भले ही मैं फीलो से सहमत हूं कि रेगेक्स शायद होना चाहिए:

/\bformat_(.*?)\b/

(लेकिन, निश्चित रूप से, मुझे यकीन नहीं है क्योंकि मुझे रेगेक्स का संदर्भ नहीं पता है।)

Comments

यह एक अलग-अलग सूची है इसलिए मुझे लगा कि यह ठीक होगा। अजीब बात है कि वह कोड मेरे (FF3 Vista) के लिए काम नहीं कर रहा था

— निक

जी हां, सच में अजीब है। क्या आपने फायरबग कंसोल में इसे अपने दम पर आजमाया है? अन्यथा खाली पृष्ठ से मेरा मतलब है।

— PEZ

Answer 15

/*Regex function for extracting object from "window.location.search" string.
 */

var search = "?a=3&b=4&c=7"; // Example search string

var getSearchObj = function (searchString) {

    var match, key, value, obj = {};
    var pattern = /(\w+)=(\w+)/g;
    var search = searchString.substr(1); // Remove '?'

    while (match = pattern.exec(search)) {
        obj[match[0].split('=')[0]] = match[0].split('=')[1];
    }

    return obj;

};

console.log(getSearchObj(search));

Answer 16

आपको कई मैचों को पार्स करने के लिए एक स्पष्ट लूप की आवश्यकता नहीं है - एक प्रतिस्थापन फ़ंक्शन को दूसरे तर्क के रूप में वर्णित करें String.prototype.replace(regex, func):

var str = "Our chief weapon is {1}, {0} and {2}!"; 
var params= ['surprise', 'fear', 'ruthless efficiency'];
var patt = /{([^}]+)}/g;

str=str.replace(patt, function(m0, m1, position){return params[parseInt(m1)];});

document.write(str);

m0तर्क पूर्ण मिलान किया सबस्ट्रिंग का प्रतिनिधित्व करता है {0}, {1}आदि m1पहले मिलान समूह, यानी हिस्सा regex जो है में कोष्ठक में प्रतिनिधित्व 0पहले मैच के लिए। और positionस्ट्रिंग के भीतर शुरुआती सूचकांक है जहां मिलान समूह पाया गया था - इस मामले में अप्रयुक्त।

Answer 17

मिलान किए गए समूह की संख्या के बाद बैकस्लैश का उपयोग करके हम मिलान किए गए समूह को एक नियमित अभिव्यक्ति में एक्सेस कर सकते हैं:

/([a-z])\1/

पहले समूह ([az]) द्वारा मेल किए गए कोड \ 1 में दर्शाया गया

Answer 18

एक पंक्ति समाधान:

const matches = (text,regex) => [...text.matchAll(regex)].map(([match])=>match)

तो आप इस तरह से उपयोग कर सकते हैं (/ g का उपयोग करना चाहिए):

matches("something format_abc", /(?:^|\s)format_(.*?)(?:\s|$)/g)

परिणाम:

[" format_abc"]

Answer 19

सभी समूह घटनाएँ प्राप्त करें

let m=[], s = "something format_abc  format_def  format_ghi";

s.replace(/(?:^|\s)format_(.*?)(?:\s|$)/g, (x,y)=> m.push(y));

console.log(m);

Answer 20

मैं आप की तरह हूं और चाहूंगा कि रेगेक्स इस तरह एक वस्तु लौटाए:

{
    match: '...',
    matchAtIndex: 0,
    capturedGroups: [ '...', '...' ]
}

फिर नीचे से फ़ंक्शन को स्निप करें

/**
 * @param {string | number} input
 *          The input string to match
 * @param {regex | string}  expression
 *          Regular expression 
 * @param {string} flags
 *          Optional Flags
 * 
 * @returns {array}
 * [{
    match: '...',
    matchAtIndex: 0,
    capturedGroups: [ '...', '...' ]
  }]     
 */
function regexMatch(input, expression, flags = "g") {
  let regex = expression instanceof RegExp ? expression : new RegExp(expression, flags)
  let matches = input.matchAll(regex)
  matches = [...matches]
  return matches.map(item => {
    return {
      match: item[0],
      matchAtIndex: item.index,
      capturedGroups: item.length > 1 ? item.slice(1) : undefined
    }
  })
}

let input = "key1:value1, key2:value2 "
let regex = /(\w+):(\w+)/g

let matches = regexMatch(input, regex)

console.log(matches)

Answer 21

बस USE RegExp। $ 1 ... $ n वें समूह जैसे:

1. पहले समूह RegExp $ 1 से मिलान करें

2. 2 समूह RegExp $ 2 से मिलान करने के लिए

यदि आप रेगेक्स एसे में 3 समूह का उपयोग करते हैं (string.match (रेगेक्स के बाद नोट का उपयोग करें))

RegExp। $ 1 RegExp। $ 2 RegExp। $ 3

 var str = "The rain in ${india} stays safe"; 
  var res = str.match(/\${(.*?)\}/ig);
  //i used only one group in above example so RegExp.$1
console.log(RegExp.$1)

//easiest way is use RegExp.$1 1st group in regex and 2nd grounp like
 //RegExp.$2 if exist use after match

var regex=/\${(.*?)\}/ig;
var str = "The rain in ${SPAIN} stays ${mainly} in the plain"; 
  var res = str.match(regex);
for (const match of res) {
  var res = match.match(regex);
  console.log(match);
  console.log(RegExp.$1)
 
}