सवाल एक पंक्ति से मेल खाने के लिए नियमित अभिव्यक्ति जिसमें कोई शब्द नहीं है?


मुझे पता है कि एक शब्द से मिलान करना संभव है और फिर अन्य टूल्स का उपयोग करके मैचों को उलट दें (उदा। grep -v)। हालांकि, मैं जानना चाहता हूं कि लाइनों से मेल खाना संभव है या नहीं नहीं नियमित अभिव्यक्ति का उपयोग करके एक विशिष्ट शब्द (उदा। हेड) होता है।

इनपुट:

hoho
hihi
haha
hede

कोड:

grep "<Regex for 'doesn't contain hede'>" input

वांछित आउटपुट:

hoho
hihi
haha

3567


मूल


शायद कुछ साल देर हो चुकी है, लेकिन इसमें क्या गलत है: ([^h]*(h([^e]|$)|he([^d]|$)|hed([^e]|$)))*? विचार सरल है। जब तक आप अवांछित स्ट्रिंग की शुरुआत नहीं देखते हैं तब तक मिलान रखें, फिर केवल एन -1 मामलों में मिलान करें जहां स्ट्रिंग अधूरा है (जहां एन स्ट्रिंग की लंबाई है)। ये एन -1 मामले "एच के बाद गैर-ई" हैं, "उसके बाद गैर-डी", और "हेड के बाद गैर-ई"। यदि आप इन एन -1 मामलों को पारित करने में कामयाब रहे हैं, तो आप सफलतापूर्वक नहीं था अवांछित स्ट्रिंग से मेल करें ताकि आप ढूंढना शुरू कर सकें [^h]* फिर - stevendesu
@stevendesu: इसे 'एक बहुत ही लंबे शब्द' या यहां तक ​​कि बेहतर आधा वाक्य के लिए आज़माएं। मज़ा टाइपिंग है। बीटीडब्ल्यू, यह लगभग अपठनीय है। प्रदर्शन प्रभाव के बारे में पता नहीं है। - Peter Schuetze
@PeterSchuetze: निश्चित रूप से यह बहुत लंबे शब्दों के लिए सुंदर नहीं है, लेकिन यह एक व्यवहार्य और सही समाधान है। यद्यपि मैंने प्रदर्शन पर परीक्षण नहीं चलाए हैं, लेकिन मैं कल्पना नहीं करता कि यह बहुत धीमी है क्योंकि बाद के नियमों में से अधिकांश को तब तक अनदेखा किया जाता है जब तक आप एच (या शब्द, वाक्य, आदि का पहला अक्षर) देखते हैं। और आप आसानी से पुनरावृत्त concatenation का उपयोग कर लंबे तारों के लिए regex स्ट्रिंग उत्पन्न कर सकते हैं। यदि यह काम करता है और जल्दी से उत्पन्न किया जा सकता है, तो क्या विरासत महत्वपूर्ण है? यही टिप्पणियां हैं। - stevendesu
@stevendesu: मैं बाद में भी हूं, लेकिन वह जवाब लगभग पूरी तरह से गलत है। एक बात के लिए, इस विषय को "एच" रखने की आवश्यकता होती है जिसे इसे नहीं करना चाहिए, यह कार्य "मिलान रेखाएं [जिसमें] एक विशिष्ट शब्द नहीं है"। आइए मान लें कि आप आंतरिक समूह को वैकल्पिक बनाने के लिए हैं, और पैटर्न को एंकर किया गया है: ^([^h]*(h([^e]|$)|he([^d]|$)|hed([^e]|$))?)*$  यह तब विफल हो जाता है जब "हेडे" के उदाहरण "हेडे" जैसे आंशिक उदाहरणों से पहले होते हैं। - jaytea
यह सवाल जोड़ा गया है स्टैक ओवरफ्लो नियमित अभिव्यक्ति अकसर किये गए सवाल, "उन्नत Regex-Fu" के तहत। - aliteralmind


जवाब:


धारणा है कि regex उलटा मिलान का समर्थन नहीं करता है पूरी तरह से सच नहीं है। नकारात्मक देखो-आस-पास का उपयोग करके आप इस व्यवहार की नकल कर सकते हैं:

^((?!hede).)*$

ऊपर regex किसी भी स्ट्रिंग, या लाइन लाइन ब्रेक के बिना मैच होगा, नहीं जिसमें (उप) स्ट्रिंग 'हेड' है। जैसा कि बताया गया है, यह कुछ regex नहीं है (या करना चाहिए) पर "अच्छा" है, लेकिन फिर भी, यह है है मुमकिन।

और यदि आपको लाइन ब्रेक वर्णों के साथ-साथ मिलान करने की आवश्यकता है, तो इसका उपयोग करें डीओटी-सभी संशोधक (पिछला s निम्नलिखित पैटर्न में):

/^((?!hede).)*$/s

या इनलाइन का उपयोग करें:

/(?s)^((?!hede).)*$/

(जहां /.../ रेगेक्स डिलीमीटर हैं, यानी, पैटर्न का हिस्सा नहीं)

यदि डीओटी-ऑल संशोधक उपलब्ध नहीं है, तो आप चरित्र वर्ग के साथ समान व्यवहार की नकल कर सकते हैं [\s\S]:

/^((?!hede)[\s\S])*$/

व्याख्या

एक स्ट्रिंग सिर्फ एक सूची है n वर्ण। इससे पहले, और प्रत्येक चरित्र के बाद, एक खाली स्ट्रिंग है। तो की एक सूची n पात्र होंगे n+1 खाली तार स्ट्रिंग पर विचार करें "ABhedeCD":

    ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐
S = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│
    └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘

index    0      1      2      3      4      5      6      7

जहां eखाली तार हैं। रेगेक्स (?!hede). यह देखने के लिए आगे देखता है कि कोई सबस्ट्रिंग नहीं है या नहीं "hede" देखा जाना चाहिए, और यदि ऐसा है (तो कुछ और देखा जाता है), फिर . (डॉट) लाइन ब्रेक को छोड़कर किसी भी चरित्र से मेल खाएगा। देखो-आसपास भी कहा जाता है शून्य-चौड़ाई-कथनों क्योंकि वे नहीं करते हैं उपभोग करना कोई पात्र वे केवल कुछ कहते हैं / मान्य करते हैं।

तो, मेरे उदाहरण में, प्रत्येक खाली स्ट्रिंग को पहले यह देखने के लिए मान्य किया जाता है कि क्या नहीं है "hede" एक चरित्र से पहले उपभोग किया जाता है, आगे बढ़ो . (डॉट)। रेगेक्स (?!hede). केवल एक बार ऐसा करेगा, इसलिए यह एक समूह में लपेटा गया है, और शून्य या अधिक बार दोहराया गया है: ((?!hede).)*। आखिरकार, स्टार्ट-एंड-एंड-इनपुट इनपुट सुनिश्चित करने के लिए लगाया जाता है कि पूरा इनपुट खाया जाता है: ^((?!hede).)*$

जैसा कि आप देख सकते हैं, इनपुट "ABhedeCD" क्योंकि विफल हो जाएगा e3, रेगेक्स (?!hede) विफल रहता है (वहां है  "hede" आगे!)।


4859



मैं अब तक यह नहीं कहूंगा कि यह कुछ रेगेक्स खराब है। इस समाधान की सुविधा बहुत स्पष्ट है और प्रोग्रामेटिक खोज की तुलना में प्रदर्शन हिट अक्सर महत्वहीन होने जा रहा है। - Archimaredes
कड़ाई से नकारात्मक झुकाव बोलने से आप नियमित अभिव्यक्ति को नियमित रूप से नियमित बनाते हैं। - Peter K
@ पीटरके, यकीन है, लेकिन यह SO है, MathOverflow या CS-Stackexchange नहीं। यहां एक प्रश्न पूछने वाले लोग आम तौर पर एक व्यावहारिक उत्तर की तलाश में हैं। अधिकांश पुस्तकालय या उपकरण (जैसे grep, जिसे ओपी का उल्लेख है) रेगेक्स-सपोर्ट के साथ सभी में ऐसी विशेषताएं हैं जो उन्हें सैद्धांतिक अर्थ में गैर-नियमित बनाती हैं। - Bart Kiers
@ बार्ट कियर्स, आपके लिए कोई अपराध नहीं है, सिर्फ शब्दावली के इस दुरुपयोग ने मुझे थोड़ा परेशान किया है। यहां वास्तव में भ्रमित करने वाला हिस्सा यह है कि सख्त अर्थ में नियमित अभिव्यक्ति ओपी चाहता है जो बहुत कुछ कर सकती है, लेकिन उन्हें लिखने की सामान्य भाषा इसे अनुमति नहीं देती है, जो आगे बढ़ने की तरह (गणितीय रूप से बदसूरत) कामकाज की ओर ले जाती है। कृपया देखें यह जवाब नीचे और मेरी टिप्पणी (सैद्धांतिक रूप से गठबंधन) करने के लिए उचित तरीका है। कहने की जरूरत नहीं है कि यह बड़े इनपुट पर तेजी से काम करता है। - Peter K
यदि आपने कभी सोचा है कि विम में ऐसा कैसे करें: ^\(\(hede\)\@!.\)*$ - baldrs


ध्यान दें कि समाधान नहीं करता के साथ शुरू "Hede":

^(?!hede).*$

आमतौर पर समाधान से अधिक कुशल है नहीं करता शामिल "Hede":

^((?!hede).)*$

प्रत्येक स्थिति के बजाय इनपुट स्ट्रिंग की पहली स्थिति में केवल "हेड" के लिए पूर्व जांच करता है।


606



धन्यवाद, मैंने यह सत्यापित करने के लिए प्रयोग किया कि स्ट्रिंग में अंकों के वर्ग नहीं हैं ^ ((?! \ D {5,})। * * - Samih A
^((?!hede).)*$ डेटासेट से स्ट्रिंग को बाहर करने के लिए jQuery डेटाटेबल प्लगइन का उपयोग करके मेरे लिए काम किया - Alex
नमस्कार! मैं लिख नहीं सकता नहीं करता समाप्त "हेड" के साथ regex। क्या आप इसके साथ मदद कर सकते हैं? - Aleks Ya
@AleksYa: बस "कंटेन" संस्करण का उपयोग करें, और खोज स्ट्रिंग में एंड एंकर शामिल करें: स्ट्रिंग को "हेड" से "हेड" से "मिलान नहीं करें" में बदलें - Nyerguds
@AleksYa: नकारात्मक संस्करण का उपयोग करके संस्करण समाप्त नहीं किया जा सकता है: (.*)(?<!hede)$। @Nyerguds का संस्करण भी काम करेगा, लेकिन जवाब के उल्लेख पर पूरी तरह से बिंदु को याद करता है। - thisismydesign


अगर आप इसे grep के लिए उपयोग कर रहे हैं, आप इसका उपयोग कर सकते हैं grep -v hede उन सभी लाइनों को प्राप्त करने के लिए जिनमें हेड नहीं है।

ईटीए ओह, सवाल फिर से पढ़ना, grep -v शायद "टूल विकल्प" से आपका क्या मतलब है।


165



युक्ति: जो आप नहीं चाहते हैं उसे प्रगतिशील रूप से फ़िल्टर करने के लिए: grep -v "hede" | grep -v "hihi" | ...आदि। - Olivier Lalonde
या केवल एक प्रक्रिया का उपयोग कर grep -v -e hede -e hihi -e ... - Olaf Dietsche
या केवल grep -v "hede\|hihi" :) - Putnik
यदि आपके पास कई पैटर्न हैं जिन्हें आप फ़िल्टर करना चाहते हैं, तो उन्हें एक फ़ाइल में रखें और उपयोग करें grep -vf pattern_file file - codeforester
या केवल egrep या grep -Ev "hede|hihi|etc" अजीब भागने से बचने के लिए। - Amit Naidu


उत्तर:

^((?!hede).)*$

स्पष्टीकरण:

^स्ट्रिंग की शुरुआत, ( समूह और \ 1 (0 या अधिक बार (अधिकतम राशि से मिलान करना) पर कब्जा),
(?! यह देखने के लिए आगे देखो कि क्या नहीं है,

hedeआपकी स्ट्रिंग,

) आगे की ओर देखो, . किसी भी चरित्र को छोड़कर \ n,
)* \ 1 का अंत (नोट: क्योंकि आप इस कैप्चर पर क्वांटिफायर का उपयोग कर रहे हैं, केवल कैप्चर किए गए पैटर्न की अंतिम पुनरावृत्ति \ 1 में संग्रहीत की जाएगी)
$ एक वैकल्पिक \ n, और स्ट्रिंग के अंत से पहले


122



कमाल है कि मेरे लिए कई शब्दों का उपयोग कर उत्कृष्ट पाठ 2 में काम किया है '^((?!DSAU_PW8882WEB2|DSAU_PW8884WEB2|DSAU_PW8884WEB).)*$' - Damodar Bashyal
@ दामोदरबाशियल मुझे पता है कि मैं यहां बहुत देर हो चुकी हूं, लेकिन आप वहां दूसरे शब्द को पूरी तरह हटा सकते हैं और आपको सटीक परिणाम मिलेंगे - forresthopkinsa


दिए गए उत्तर बिल्कुल ठीक हैं, सिर्फ एक अकादमिक बिंदु:

सैद्धांतिक कंप्यूटर विज्ञान के अर्थ में नियमित अभिव्यक्तियां अभी तक नहीं हैं इसको ऐसे करो। उनके लिए इसे कुछ ऐसा दिखना पड़ा:

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$) 

यह केवल एक पूर्ण मैच करता है। उप-मैचों के लिए ऐसा करना और भी अजीब होगा।


90



यह ध्यान रखना महत्वपूर्ण है कि यह केवल मूल POSIX.2 नियमित अभिव्यक्तियों का उपयोग करता है और इस प्रकार पीसीआरई उपलब्ध नहीं होने पर टेर्स अधिक पोर्टेबल है। - Steve-o
मैं सहमत हूँ। बहुत से लोग नियमित रूप से नियमित अभिव्यक्ति नहीं करते हैं और एक सीमित ऑटोमाटा द्वारा पहचाना नहीं जा सकता है। - ThomasMcLeod
@ थॉमस एमसीएलओड, हेड्स 32: क्या यह किसी भी संभावित नियमित भाषा के क्षेत्र में है जो कहने में सक्षम है 'नहीं' तथा 'तथा' इसके साथ ही 'याएक अभिव्यक्ति की तरह '(hede|Hihi)'? (यह शायद सीएस के लिए एक सवाल है।) - James Haigh
@JohnAllen: ME !!! ... ठीक है, वास्तविक regex नहीं बल्कि अकादमिक संदर्भ, जो भी कम्प्यूटेशनल जटिलता से बारीकी से संबंधित है; पीसीआरई मूल रूप से पीओएसईक्स नियमित अभिव्यक्तियों के समान दक्षता की गारंटी नहीं दे सकते हैं। - James Haigh
क्षमा करें- यह जवाब सिर्फ काम नहीं करता है, यह हहे से मेल खाता है और यहां तक ​​कि आंशिक रूप से मेल खाता है (दूसरा आधा) - Falco


यदि आप रेगेक्स परीक्षण चाहते हैं केवल अगर असफल हो पूरी स्ट्रिंग मैच, निम्नलिखित काम करेंगे:

^(?!hede$).*

जैसे - यदि आप "foo" को छोड़कर सभी मानों को अनुमति देना चाहते हैं (यानी "foofoo", "barfoo", और "foobar" पास हो जाएंगे, लेकिन "foo" विफल हो जाएगा), उपयोग करें: ^(?!foo$).*

बेशक, यदि आप की जांच कर रहे हैं सटीक समानता, इस मामले में एक बेहतर सामान्य समाधान स्ट्रिंग समानता की जांच करना है, यानी।

myStr !== 'foo'

आप भी निषेध डाल सकते हैं बाहर परीक्षण अगर आपको किसी रेगेक्स फीचर्स की आवश्यकता है (यहां, केस असंवेदनशीलता और सीमा मिलान):

!/^[a-f]oo$/i.test(myStr)

शीर्ष पर रेगेक्स समाधान सहायक हो सकता है, हालांकि, ऐसी परिस्थितियों में जहां एक सकारात्मक रेगेक्स परीक्षण की आवश्यकता होती है (शायद एक एपीआई द्वारा)।


49



सफेद जगहों के पीछे क्या है? उदाहरण के लिए, अगर मैं स्ट्रिंग के साथ परीक्षण विफल होना चाहता हूँ " hede "? - eagor
@ इगोर द \s निर्देश एक सिंगल व्हाइटस्पेस चरित्र से मेल खाता है - Roy Tinker
धन्यवाद, लेकिन मैंने यह काम करने के लिए रेगेक्स को अपडेट करने का प्रबंधन नहीं किया। - eagor
@eagor: ^(?!\s*hede\s*$).* - Roy Tinker


यहां बताया गया है एक अच्छा स्पष्टीकरण एक मनमानी regex को अस्वीकार करना क्यों आसान नहीं है। मुझे अन्य उत्तरों से सहमत होना है, हालांकि: यदि यह एक काल्पनिक प्रश्न के अलावा कुछ भी है, तो एक रेगेक्स यहां सही विकल्प नहीं है।


48



कुछ टूल्स, और विशेष रूप से mysqldumpslow, केवल डेटा फ़िल्टर करने के लिए इस तरह की पेशकश करते हैं, इसलिए ऐसे मामले में, ऐसा करने के लिए रेगेक्स ढूंढना टूल को फिर से लिखने के अलावा सबसे अच्छा समाधान है (इसके लिए विभिन्न पैच MySQL AB / Sun द्वारा शामिल नहीं किए गए हैं / आकाशवाणी। - FGM
मेरी स्थिति के लिए बिल्कुल समान है। वेग टेम्पलेट इंजन एक अभिव्यक्ति को लागू करने के लिए नियमित अभिव्यक्तियों का उपयोग करता है (एचटीएमएल से बचें) और मैं चाहता हूं कि यह हमेशा एक स्थिति में EXCEPT काम करे। - Henno Vermeulen
वहां क्या विकल्प है? मैंने कभी भी ऐसा कुछ भी नहीं सामना किया जो रेगेक्स के अलावा सटीक स्ट्रिंग मिलान कर सकता था। यदि ओपी प्रोग्रामिंग भाषा का उपयोग कर रहा है, तो अन्य टूल्स उपलब्ध हो सकते हैं, लेकिन यदि वह कोड लिखने का उपयोग नहीं कर रहा है, तो शायद कोई अन्य विकल्प नहीं है। - kingfrito_5005
कई गैर-काल्पनिक परिदृश्यों में से एक जहां रेगेक्स सबसे अच्छा उपलब्ध विकल्प है: मैं एक आईडीई (एंड्रॉइड स्टूडियो) में हूं जो लॉग आउटपुट दिखाता है, और प्रदान किए गए एकमात्र फ़िल्टरिंग टूल हैं: सादे स्ट्रिंग्स और रेगेक्स। सादे तारों के साथ ऐसा करने की कोशिश करना एक पूर्ण असफल होगा। - LarsH


एफडब्ल्यूआईडब्ल्यू, चूंकि नियमित भाषाएं (उर्फ तर्कसंगत भाषाएं) पूरक के तहत बंद होती हैं, इसलिए नियमित अभिव्यक्ति (उर्फ तर्कसंगत अभिव्यक्ति) ढूंढना हमेशा संभव होता है जो एक और अभिव्यक्ति को अस्वीकार करता है। लेकिन कई टूल इसे लागू नहीं करते हैं।

Vcsn इस ऑपरेटर का समर्थन करता है (जो यह दर्शाता है {c}, पोस्टफिक्स)।

आप पहले अपनी अभिव्यक्ति के प्रकार को परिभाषित करते हैं: लेबल अक्षर हैं (lal_char) से चुनने के लिए a सेवा मेरे z उदाहरण के लिए (पूरक के साथ काम करते समय वर्णमाला को परिभाषित करना, ज़ाहिर है, बहुत महत्वपूर्ण है), और प्रत्येक शब्द के लिए गणना की गई "मान" सिर्फ एक बूलियन है: true शब्द स्वीकार किया जाता है, false, अस्वीकृत।

पायथन में:

In [5]: import vcsn
        c = vcsn.context('lal_char(a-z), b')
        c
Out[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → 𝔹

तो आप अपनी अभिव्यक्ति दर्ज करें:

In [6]: e = c.expression('(hede){c}'); e
Out[6]: (hede)^c

इस अभिव्यक्ति को एक automaton में परिवर्तित करें:

In [7]: a = e.automaton(); a

The corresponding automaton

आखिरकार, इस automaton को वापस एक साधारण अभिव्यक्ति में परिवर्तित करें।

In [8]: print(a.expression())
        \e+h(\e+e(\e+d))+([^h]+h([^e]+e([^d]+d([^e]+e[^]))))[^]*

कहा पे + आमतौर पर दर्शाया जाता है |, \e खाली शब्द इंगित करता है, और [^] आमतौर पर लिखा जाता है . (कोई चरित्र)। तो, कुछ पुनर्लेखन के साथ ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*

आप यह उदाहरण देख सकते हैं यहाँ, और वीसीएसएन ऑनलाइन कोशिश करें क्या आप वहां मौजूद हैं


44



सच है, लेकिन बदसूरत, और केवल छोटे चरित्र सेट के लिए करने योग्य। आप यूनिकोड तारों के साथ ऐसा नहीं करना चाहते हैं :-) - reinierpost
ऐसे कई टूल हैं जो इसे सबसे प्रभावशाली होने की अनुमति देते हैं Ragel। वहां इसे बिना किसी गठबंधन के लिए (किसी भी * - ('हेहे' किसी भी *) के रूप में लिखा जाएगा) या किसी भी * - ('हेहे' किसी भी *))। - Peter K
@reinierpost: यह बदसूरत क्यों है और यूनिकोड के साथ क्या समस्या है? मैं दोनों पर सहमत नहीं हो सकता। (मुझे वीसीएसएन के साथ कोई अनुभव नहीं है, लेकिन डीएफए के साथ है)। - Peter K
Regexp ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).* मेरे लिए काम नहीं किया egrep। मेल खा रहा है hede। मैंने शुरुआत और अंत तक इसे एंकर करने की भी कोशिश की, और यह अभी भी काम नहीं कर सका। - Pedro Gimeno
@PedroGimeno जब आप लंगरते हैं, तो आप इस रेगेक्स को पहले माता-पिता में रखना सुनिश्चित करते हैं? अन्यथा एंकरों के बीच की प्राथमिकताओं और | अच्छी तरह से खेल नहीं होगा। '^(()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*)$'। - akim


मानक

मैंने कुछ प्रस्तुत विकल्पों का मूल्यांकन करने और उनके प्रदर्शन की तुलना करने का निर्णय लिया, साथ ही कुछ नई सुविधाओं का उपयोग करने का निर्णय लिया। .NET Regex इंजन पर बेंचमार्किंग: http://regexhero.net/tester/

बेंचमार्क टेक्स्ट:

पहली 7 लाइनों का मिलान नहीं होना चाहिए, क्योंकि उनमें खोजी अभिव्यक्ति होती है, जबकि निचले 7 लाइनों का मिलान होना चाहिए!

Regex Hero is a real-time online Silverlight Regular Expression Tester.
XRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero
egex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester.
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester.

Regex Her
egex Hero
egex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester.
Nobody is a real-time online Silverlight Regular Expression Tester.
Regex Her o egex Hero Regex  Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester.

परिणाम:

परिणाम 3 सेकंड के औसत के रूप में प्रति सेकंड Iterations हैं - बड़ी संख्या = बेहतर

01: ^((?!Regex Hero).)*$                    3.914   // Accepted Answer
02: ^(?:(?!Regex Hero).)*$                  5.034   // With Non-Capturing group
03: ^(?>[^R]+|R(?!egex Hero))*$             6.137   // Lookahead only on the right first letter
04: ^(?>(?:.*?Regex Hero)?)^.*$             7.426   // Match the word and check if you're still at linestart
05: ^(?(?=.*?Regex Hero)(?#fail)|.*)$       7.371   // Logic Branch: Find Regex Hero? match nothing, else anything

P1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT))  ?????   // Logic Branch in Perl - Quick FAIL
P2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ?????   // Direct COMMIT & FAIL in Perl

चूंकि .NET कार्रवाई क्रियाओं का समर्थन नहीं करता है (* असफल, आदि) मैं समाधान पी 1 और पी 2 का परीक्षण नहीं कर सका।

सारांश:

मैंने सबसे प्रस्तावित समाधानों का परीक्षण करने की कोशिश की, कुछ अनुकूलन कुछ शब्दों के लिए संभव है। उदाहरण के लिए यदि खोज स्ट्रिंग के पहले दो अक्षर समान नहीं हैं, तो उत्तर 03 को विस्तारित किया जा सकता है ^(?>[^R]+|R+(?!egex Hero))*$ जिसके परिणामस्वरूप एक छोटा प्रदर्शन लाभ हुआ।

लेकिन एकमात्र सबसे पठनीय और प्रदर्शन-वार सबसे तेज़ समाधान सशर्त कथन का उपयोग करते हुए 05 लगता है या 04 संभावित मात्रात्मक क्वांटिफायर के साथ। मुझे लगता है कि पर्ल समाधान भी तेज और अधिक आसानी से पठनीय होना चाहिए।


39



आपको समय चाहिए ^(?!.*hede) भी। /// इसके अलावा, मेलिंग कॉर्पस और गैर-मेलिंग कॉर्पस के लिए अलग-अलग अभिव्यक्तियों को रैंक करना शायद बेहतर होता है क्योंकि आमतौर पर यह एक ऐसा मामला है जो अधिकतर लाइन मिलान या अधिकतर रेखाएं नहीं करता है। - ikegami


नकारात्मक लुकहेड के साथ, नियमित अभिव्यक्ति कुछ ऐसे पैटर्न से मेल खा सकती है जिसमें विशिष्ट पैटर्न नहीं है। बार्ट कियर्स द्वारा इसका उत्तर और समझाया गया है। महान स्पष्टीकरण!

हालांकि, बार्ट कियर्स के जवाब के साथ, लुकहेड भाग किसी एकल चरित्र से मेल खाने के दौरान आगे 1 से 4 वर्णों का परीक्षण करेगा। हम इससे बच सकते हैं और लुकहेड पार्ट पूरे टेक्स्ट को देख सकते हैं, सुनिश्चित करें कि कोई 'हेड' नहीं है, और फिर सामान्य भाग (। *) पूरे टेक्स्ट को एक ही समय में खा सकता है।

यहां सुधारित रेगेक्स है:

/^(?!.*?hede).*$/

ध्यान दें कि नकारात्मक लुकहेड भाग में (*?) आलसी क्वांटिफ़ायर वैकल्पिक है, आप अपने डेटा के आधार पर (*) लालची क्वांटिफायर का उपयोग कर सकते हैं: यदि 'हेड' मौजूद है और पाठ के शुरुआती भाग में, आलसी क्वांटिफ़ायर तेज हो; अन्यथा, लालची क्वांटिफायर तेज़ हो। हालांकि अगर 'हेड' मौजूद नहीं है, तो दोनों बराबर धीमे होंगे।

यहाँ है डेमो कोड

लुकहेड के बारे में अधिक जानकारी के लिए, कृपया महान लेख देखें: मास्टरिंग लुकहेड और लुकबेइंड

इसके अलावा, कृपया जांचें RegexGen.js, एक जावास्क्रिप्ट नियमित अभिव्यक्ति जेनरेटर जो जटिल नियमित अभिव्यक्तियों को बनाने में मदद करता है। RegexGen.js के साथ, आप रेगेक्स को एक और अधिक पठनीय तरीके से बना सकते हैं:

var _ = regexGen;

var regex = _(
    _.startOfLine(),             
    _.anything().notContains(       // match anything that not contains:
        _.anything().lazy(), 'hede' //   zero or more chars that followed by 'hede',
                                    //   i.e., anything contains 'hede'
    ), 
    _.endOfLine()
);

37



तो बस यह जांचने के लिए कि क्या दिए गए स्ट्रिंग में str1 और str2 नहीं है: ^(?!.*(str1|str2)).*$ - S.Serp
हाँ, या आप आलसी मात्रात्मक का उपयोग कर सकते हैं: ^(?!.*?(?:str1|str2)).*$, आपके डेटा के आधार पर। जोड़ा गया ?: चूंकि हमें इसे पकड़ने की आवश्यकता नहीं है। - amobiz
यह 10xms के कारक द्वारा अब तक का सबसे अच्छा जवाब है। यदि आपने अपना jsfiddle कोड जोड़ा और उत्तर पर परिणाम लोगों को यह नोटिस हो सकता है। मुझे आश्चर्य है कि आलसी संस्करण लालसा संस्करण से तेज क्यों है जब कोई हेड नहीं है। क्या वे एक ही समय नहीं लेना चाहिए? - user5389726598465
हां, वे एक ही समय लेते हैं क्योंकि वे दोनों पूरे पाठ का परीक्षण करते हैं। - amobiz