Regex

Question

अग्रावलोकन मैं एक regex उपयोग कर रहा हूँ लगता है:

test:? 

अब जब मैं इस regex मैंने बनाया चलाएँ::

test:? 

किसी भी चरित्र इसके बाद जब तक यह अगले हिट

((?:test:\?)(.*)(?!test:\?)) 

इस पाठ पर:

test:?foo2=bar2&baz2=foo2test:?foo=bar&baz=footest:?foo2=bar2&baz2=foo2 

मैं मिलने की उम्मीद:

test:?foo2=bar2&baz2=foo2 

test:?foo=bar&baz=foo 

test:?foo2=bar2&baz2=foo2 

लेकिन बजाय यह सबसे मेल खाता। क्या कोई रेगेक्स अनुभव वाला कोई व्यक्ति जानता है कि मैं गलत कहां गया हूं? मैंने पहले पैटर्न मिलान के लिए रेगेक्स का उपयोग किया है, लेकिन यह लुकराउंड/अग्रेषण का मेरा पहला अनुभव है।

:-)

Answer 1

मुझे लगता है कि आप एक लालची संस्करण का पता लगा सकते हैं।
(विस्तारित)

(test:\? (?: (?!test:\?)[\s\S])*)

Answer 2

कोई मदद/सुझाव दिए गए/संकेत के लिए अग्रिम धन्यवाद आप शायद, ((?:test:\?)(.*?)(?=test:\?)) चाहते यद्यपि आप हमें आप किस भाषा regexes ड्राइव करने के लिए प्रयोग कर रहे हैं नहीं बताया है।

.*? मैचों संभव के रूप में कुछ वर्ण मिलान, जहां .* मैचों के रूप में कई संभव के रूप में (लालची है) से पूरी स्ट्रिंग को रोकने के बिना।

निर्भर करते हुए, आप इस भाषा के लिए किस भाषा का उपयोग कर रहे हैं, इसके बाद आपको शायद मिलान करने की आवश्यकता होगी, फिर स्ट्रिंग काट लें, फिर दोबारा मिलान करें, या कुछ भाषा-विशिष्ट match_all प्रकार फ़ंक्शन को कॉल करें।

वैसे, आप (आप बस के लिए, इसके बजाय खोज की आकार से मिलान कर सकते हैं) एक अग्रदर्शी का उपयोग कर एक regex लंगर की जरूरत नहीं है, तो यह (सबसे अधिक संभावना) अपने मामले में क्या होगा:

test:[?](.*?)test:[?] 

Answer 3

तीन मुद्दों:

• (?!) एक नकारात्मक अग्रदर्शी दावा है। आप इसके बजाय (?=) चाहते हैं, इसके बाद जो भी आता है वह test:? है।

• .* लालची है; आप इसे लालची चाहते हैं ताकि आप केवल पहले खंड को पकड़ सकें।

• आप अंतिम खंड भी चाहते हैं, तो आप अंत में $ से मिलान करना चाहते हैं।

अंत परिणाम:

(?:test:\?)(.*?)(?=test:\?|$) 

मैं भी बाहरी समूह को हटा दिया गया है, यह करने का कोई मतलब देखकर। सभी आरई इंजन जिन्हें मैं जानता हूं कि आपको ग्रुप 0 को पूर्ण मैच, या कुछ अन्य तरीकों से एक्सेस करने देता है (हालांकि शायद सभी मैचों को ढूंढते समय नहीं)। यदि आपको आवश्यकता हो तो आप इसे वापस रख सकते हैं।

(यह PCRE में काम करता है, यकीन है कि अगर यह, POSIX रेगुलर एक्सप्रेशन के साथ काम करेगा के रूप में मैं उनके साथ काम करने की आदत नहीं कर रहा हूँ नहीं।)

तुम सिर्फ test:? पर विभाजित करने के लिए इच्छुक रहे हैं, हालांकि, नियमित अभिव्यक्ति गलत उपकरण हैं। ऐसी चीजों के लिए अपनी भाषा के इनबिल्ट समर्थन का उपयोग करके तारों को विभाजित करें।

पायथन:

>>> re.findall('(?:test:\?)(.*?)(?=test:\?|$)', 
... 'test:?foo2=bar2&baz2=foo2test:?foo=bar&baz=footest:?foo2=bar2&baz2=foo2') 
['foo2=bar2&baz2=foo2', 'foo=bar&baz=foo', 'foo2=bar2&baz2=foo2'] 

Answer 4

पर्ल कार्यक्रम

नीचे

#! /usr/bin/env perl 

use strict; 
use warnings; 

$_ = "test:?foo2=bar2&baz2=foo2test:?foo=bar&baz=footest:?foo2=bar2&baz2=foo2"; 

while (/(test:\? .*?) (?= test:\? | $)/gx) { 
    print "[$1]\n"; 
} 

अपने प्रश्न से वांछित उत्पादन का उत्पादन, के साथ साथ जोर देने के लिए कोष्ठक।

[test:?foo2=bar2&baz2=foo2] 
[test:?foo=bar&baz=foo] 
[test:?foo2=bar2&baz2=foo2]

याद रखें कि regex quantifiers are greedy और मैच को तोड़ने के बिना वे कर सकते हैं जितना ऊपर हडप जाना चाहते हैं। जितनी जल्दी हो सके समाप्त करने के लिए प्रत्येक उपधारा, जिसका अर्थ है .*? अर्थशास्त्र।

प्रत्येक subsegment साथ समाप्त हो जाता है या तो एक और test:? या अंत के स्ट्रिंग है, जो हम (?=...) शून्य चौड़ाई विकल्प | के चारों ओर लिपटा अग्रदर्शी साथ के लिए देखो।

उपरोक्त कोड में पैटर्न Perl’s /x regex switch को पढ़ने योग्यता के लिए उपयोग करता है। भाषा और पुस्तकालयों के आधार पर आप ’ फिर से उपयोग कर रहे हैं, तो आपको अतिरिक्त व्हाइटस्पेस को हटाने की आवश्यकता हो सकती है।