मैच के लिए रेगेक्स पैटर्न, को छोड़कर ... के बीच / को छोड़कर

Question

--Edit-- वर्तमान उत्तरों में कुछ उपयोगी विचार हैं, लेकिन मैं कुछ और पूर्ण करना चाहता हूं जिसे मैं 100% समझ सकता हूं और पुन: उपयोग कर सकता हूं; इसलिए मैंने एक इनाम निर्धारित किया है। इसके अलावा, हर जगह काम करने वाले विचार मेरे लिए बेहतर हैं जो मानक वाक्यविन्यास की तरह नहीं हैं\K

यह प्रश्न इस बारे में है कि मैं कुछ स्थितियों को छोड़कर कैसे एक पैटर्न का मिलान कर सकता हूं s1 s2 s3। मैं अपना अर्थ दिखाने के लिए एक विशिष्ट उदाहरण देता हूं लेकिन एक सामान्य उत्तर पसंद करता हूं जिसे मैं 100% समझ सकता हूं इसलिए मैं इसे अन्य स्थितियों में पुन: उपयोग कर सकता हूं।

उदाहरण

मैं पाँच अंकों का मिलान करना चाहता हूं \b\d{5}\bलेकिन तीन स्थितियों में नहीं s1 s2 s3:

s1: इस वाक्य जैसी अवधि के साथ समाप्त होने वाली पंक्ति पर नहीं।

s2: कहीं भी अंदर parens नहीं।

s3: किसी ऐसे ब्लॉक के अंदर नहीं, जिसके साथ शुरू होता है if(और समाप्त होता है//endif

मुझे पता है कि एस 1 एस 2 एस 3 में से किसी को भी एक लुकहैड और लुकबाइंड के साथ हल करना है, खासकर सी # लुकबाइंड या \Kपीएचपी में।

उदाहरण के लिए

एस 1 (?m)(?!\d+.*?\.$)\d+

s3 के साथ C # दिखे (?<!if\(\D*(?=\d+.*?//endif))\b\d+\b

PHP3 के साथ s3 (?:(?:if\(.*?//endif)\D*)*\K\d+

लेकिन एक साथ स्थितियों का मिश्रण मेरे सिर को विस्फोट कर देता है। इससे भी बुरी खबर यह है कि मुझे एक समय में अन्य शर्तों s4 s5 को जोड़ने की आवश्यकता हो सकती है।

अच्छी खबर यह है कि मुझे परवाह नहीं है अगर मैं PHP, C #, पायथन या मेरे पड़ोसी की वॉशिंग मशीन जैसी अधिकांश सामान्य भाषाओं का उपयोग करके फ़ाइलों को संसाधित करता हूं। :) मैं पायथन और जावा में बहुत शुरुआत कर रहा हूं, लेकिन यह जानने के लिए दिलचस्पी है कि क्या इसका कोई हल है।

इसलिए मैं यहां यह देखने आया कि क्या कोई लचीली रेसिपी के बारे में सोचता है।

संकेत ठीक हैं: आपको मुझे पूर्ण कोड देने की आवश्यकता नहीं है। :)

धन्यवाद।

Comments

\Kकोई विशेष php सिंटैक्स नहीं है। कृपया विस्तृत करें और स्पष्ट करें कि आप क्या कहना चाहते हैं। यदि आप हमें यह बताने के लिए लक्ष्य रखते हैं कि आपको "जटिल" समाधान की आवश्यकता नहीं है, तो आपको यह कहना होगा कि आपके लिए और क्यों जटिल है।

— हैकर

@ खकरे का मतलब है क्योंकि माणिक अब इसका उपयोग कर रहे हैं और यह पर्ल में शुरू हुआ है?

— हंस शिंडलर

नहीं, क्योंकि यह PCRE है जो PHP (और न ही रूबी) नहीं है। पर्ल अलग है लेकिन PCRE का उद्देश्य पर्ल रेगेक्स संगत होना है।

— हैकर

आपकी s2 और s3 आवश्यकताएँ विरोधाभासी प्रतीत होती हैं। s2 का तात्पर्य है कि कोष्ठक हमेशा मेल खाते हैं और घोंसले के शिकार हो सकते हैं, लेकिन s3 के लिए आवश्यक है कि: "if("खुले परन को बंद किया जाए, न कि a के साथ ")", बल्कि a: के साथ "//endif"? और अगर s3 के लिए आपका वास्तव में मतलब था कि यदि क्लॉज़ को बंद किया जाना चाहिए: "//endif)"तो, s3 आवश्यकता s2 का सबसेट है।

— बजकर

@ ठाकरे हां, मैं जानता हूं कि पीसीआरई को समझाने के लिए, सवाल प्रोग्रामिंग लैंग्वेज के बारे में है ... यह कहता है especially in C# lookbehind or \K in PHP... लेकिन C # लुकअप न सिर्फ C # इट्स .NET है, इसलिए आप शिकायत कर सकते हैं कि मैं भी C # नहीं .NET :) और जवाब में कहता हूं रूबी नहीं ओनिगुरमा यह भी बुरा है ... क्या एक और भाषा है जो पीसीआरई का उपयोग करती है? नोटपैड ++ या सर्वर टूल के बारे में बात नहीं करना यह सवाल है कि भाषा में फीचर का उपयोग करने के बारे में मुझे आशा है कि अगर यह गलत लगता है तो क्षमा करें और क्षमा करें

— हंस शिंडलर

Answer 1

हंस, मैं चारा और मांस को अपने पहले के उत्तर से निकालूंगा। आपने कहा कि आप "कुछ अधिक पूर्ण" चाहते हैं, इसलिए मुझे आशा है कि आप लंबे उत्तर को ध्यान में नहीं रखेंगे - कृपया प्रसन्न करने की कोशिश करेंगे। चलो कुछ पृष्ठभूमि के साथ शुरू करते हैं।

सबसे पहले, यह एक उत्कृष्ट सवाल है। कुछ संदर्भों (उदाहरण के लिए, एक कोड ब्लॉक के भीतर या कोष्ठक के भीतर) को छोड़कर कुछ पैटर्न के मिलान के बारे में अक्सर सवाल होते हैं। ये प्रश्न अक्सर काफी अजीब समाधानों को जन्म देते हैं। इसलिए कई संदर्भों के बारे में आपका प्रश्न एक विशेष चुनौती है।

आश्चर्य

आश्चर्यजनक रूप से, कम से कम एक कुशल समाधान है जो सामान्य है, लागू करना आसान है और बनाए रखने के लिए एक खुशी है। यह सभी रेगेक्स फ्लेवर के साथ काम करता है जो आपको अपने कोड में कैप्चर समूहों का निरीक्षण करने की अनुमति देता है। और यह कई सामान्य सवालों के जवाब देने के लिए होता है जो पहली बार आपसे अलग लग सकते हैं: "डोनट्स को छोड़कर सब कुछ मैच करें", "सभी को बदलें लेकिन ...", "मेरी माँ की काली सूची को छोड़कर सभी शब्दों को मिलाएं", "अनदेखा करें टैग "," तापमान मिलान जब तक italicized "...

अफसोस की बात है, तकनीक अच्छी तरह से ज्ञात नहीं है: मेरा अनुमान है कि बीस एसओ प्रश्नों में जो इसका उपयोग कर सकते हैं, केवल एक के पास एक उत्तर है जो इसका उल्लेख करता है - जिसका अर्थ है कि शायद पचास या साठ उत्तरों में से एक। टिप्पणियों में कोबी के साथ मेरा आदान-प्रदान देखें। इस लेख में तकनीक को कुछ गहराई से वर्णित किया गया है जो इसे (आशावादी रूप से) "सर्वश्रेष्ठ रेगेक्स ट्रिक" कहता है। ज्यादा विस्तार में जाने के बिना, मैं आपको यह बताने की कोशिश करूंगा कि तकनीक कैसे काम करती है। विभिन्न भाषाओं में अधिक विस्तार और कोड नमूनों के लिए मैं आपको उस संसाधन से परामर्श करने के लिए प्रोत्साहित करता हूं।

एक बेहतर-ज्ञात विविधता

पर्ल और PHP के लिए सिंटैक्स विशिष्ट का उपयोग करके एक भिन्नता है जो समान है। आप इस तरह के रूप में रेगुलर एक्सप्रेशन से स्वामी के हाथ में इतने पर यह देखेंगे CasimiretHippolyte और हमजा । मैं आपको इसके बारे में और नीचे बताऊंगा, लेकिन यहां मेरा ध्यान सामान्य समाधान पर है जो सभी regex जायके के साथ काम करता है (जब तक आप अपने कोड में कैप्चर समूहों का निरीक्षण कर सकते हैं)।

सभी पृष्ठभूमि के लिए धन्यवाद, zx81 ... लेकिन नुस्खा क्या है?

मुख्य तथ्य

विधि समूह 1 कैप्चर में मैच लौटाती है। यह समग्र मैच के बारे में बिल्कुल भी परवाह नहीं करता है।

वास्तव में, ट्रिक उन विभिन्न संदर्भों से मेल खाती है , जिन्हें हम नहीं चाहते हैं ( |या संदर्भ / विकल्प का उपयोग करके इन संदर्भों का पीछा करते हुए ) ताकि "उन्हें बेअसर कर सकें"। सभी अवांछित संदर्भों के मिलान के बाद, प्रत्यावर्तन के अंतिम भाग से हम क्या चाहते हैं और इसे समूह 1 में कैप्चर करता है।

सामान्य नुस्खा है

Not_this_context|Not_this_either|StayAway|(WhatYouWant)

यह मैच करेगा Not_this_context, लेकिन इस मायने में कि मैच एक कचरा बिन में चला जाता है, क्योंकि हम समग्र मैचों को नहीं देखेंगे: हम केवल ग्रुप 1 कैप्चर को देखते हैं।

आपके मामले में, आपके अंकों और आपके तीन संदर्भों को अनदेखा करने के लिए, हम कर सकते हैं:

s1|s2|s3|(\b\d+\b)

ध्यान दें कि क्योंकि हम वास्तव में s1, s2 और s3 से मिलते-जुलते हैं, ताकि वे लुकरॉइड्स से बचने की कोशिश कर रहे हैं, s1, s2 और s3 के लिए अलग-अलग भाव दिन के रूप में स्पष्ट रह सकते हैं। (वे प्रत्येक के उप भाग हैं |)

पूरी अभिव्यक्ति को इस तरह लिखा जा सकता है:

(?m)^.*\.$|\([^\)]*\)|if\(.*?//endif|(\b\d+\b)

यह डेमो देखें (लेकिन निचले दाएं फलक में कैप्चर समूहों पर ध्यान केंद्रित करें।)

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

फ्री-स्पेसिंग का समर्थन करने वाले स्वादों के लिए, यह विशेष रूप से अच्छी तरह से पढ़ता है।

(?mx)
      ### s1: Match line that ends with a period ###
^.*\.$  
|     ### OR s2: Match anything between parentheses ###
\([^\)]*\)  
|     ### OR s3: Match any if(...//endif block ###
if\(.*?//endif  
|     ### OR capture digits to Group 1 ###
(\b\d+\b)

यह असाधारण रूप से पढ़ने और बनाए रखने में आसान है।

रेगेक्स का विस्तार

जब आप अधिक स्थितियों को s4 और s5 को अनदेखा करना चाहते हैं, तो आप उन्हें बाईं ओर अधिक विकल्पों में जोड़ते हैं:

s4|s5|s1|s2|s3|(\b\d+\b)

यह कैसे काम करता है?

जिन संदर्भों को आप नहीं चाहते हैं, उन्हें बाईं ओर के विकल्पों की सूची में जोड़ा जाता है: वे मेल खाएंगे, लेकिन इन समग्र मैचों की कभी जांच नहीं की जाती है, इसलिए उनका मिलान करना उन्हें "कचरा बिन" में डालने का एक तरीका है।

हालाँकि आप जो सामग्री चाहते हैं, वह ग्रुप 1 पर कब्जा कर ली गई है। फिर आपको प्रोग्रामेटिक रूप से यह देखना होगा कि ग्रुप 1 सेट है और खाली नहीं है। यह एक तुच्छ प्रोग्रामिंग कार्य है (और हम बाद में बात करेंगे कि यह कैसे किया जाता है), विशेष रूप से यह देखते हुए कि यह आपको एक सरल रीगेक्स के साथ छोड़ देता है जिसे आप एक नज़र में समझ सकते हैं और आवश्यकतानुसार संशोधित या विस्तारित कर सकते हैं।

मैं हमेशा विज़ुअलाइज़ेशन का प्रशंसक नहीं हूं, लेकिन यह दिखाने का एक अच्छा काम करता है कि विधि कितनी सरल है। प्रत्येक "लाइन" एक संभावित मैच से मेल खाती है, लेकिन केवल निचला रेखा समूह 1 में कब्जा कर लिया गया है।

डीबगेजक्स डेमो

पर्ल / पीसीआर भिन्नता

ऊपर दिए गए सामान्य समाधान के विपरीत, पर्ल और पीसीआरई के लिए भिन्नता मौजूद है जो अक्सर SO पर देखी जाती है, कम से कम regex Gods जैसे @CasimiretHippolyte और @ HamZa के हाथों में। यह है:

(?:s1|s2|s3)(*SKIP)(*F)|whatYouWant

आपके मामले में:

(?m)(?:^.*\.$|\([^()]*\)|if\(.*?//endif)(*SKIP)(*F)|\b\d+\b

यह भिन्नता उपयोग करने में थोड़ी आसान है क्योंकि संदर्भों s1, s2 और s3 में मिलान की गई सामग्री बस छोड़ दी जाती है, इसलिए आपको समूह 1 कैप्चर (कोष्ठक हट गए हैं) का निरीक्षण करने की आवश्यकता नहीं है। मैच केवल होते हैंwhatYouWant

ध्यान दें (*F), (*FAIL)और (?!)सभी एक ही चीज हैं। यदि आप अधिक अस्पष्ट होना चाहते हैं, तो आप उपयोग कर सकते हैं(*SKIP)(?!)

इस संस्करण के लिए डेमो

अनुप्रयोग

यहां कुछ सामान्य समस्याएं हैं जिन्हें यह तकनीक अक्सर आसानी से हल कर सकती है। आप देखेंगे कि शब्द का चुनाव इन समस्याओं में से कुछ को अलग कर सकता है जबकि वास्तव में वे वास्तव में समान हैं।

1. मैं टैग जैसे टैग को छोड़कर कहीं से भी कैसे मैच कर सकता हूं <a stuff...>...</a>?
2. मैं <i>टैग या जावास्क्रिप्ट स्निपेट (अधिक शर्तों) को छोड़कर फू से कैसे मिलान कर सकता हूं ?
3. मैं उन सभी शब्दों से कैसे मेल कर सकता हूं जो इस ब्लैक लिस्ट में नहीं हैं?
4. मैं किसी SUB ... END SUB ब्लॉक के अंदर कुछ भी कैसे अनदेखा कर सकता हूं?
5. मैं सब कुछ कैसे मिला सकता हूं ... s1 s2 s3?

ग्रुप 1 कैप्चर को कैसे प्रोग्राम करें

आप कोड के लिए नहीं थे, लेकिन, पूरा होने के लिए ... समूह 1 का निरीक्षण करने के लिए कोड स्पष्ट रूप से आपकी पसंद की भाषा पर निर्भर करेगा। किसी भी दर पर यह उस कोड की एक जोड़ी से अधिक नहीं जोड़ना चाहिए जिस कोड का आप मैचों का निरीक्षण करेंगे।

यदि संदेह है, तो मैं आपको पहले उल्लेखित लेख के कोड नमूने अनुभाग को देखने की सलाह देता हूं , जो काफी कुछ भाषाओं के लिए कोड प्रस्तुत करता है।

वैकल्पिक

प्रश्न की जटिलता पर निर्भर करता है, और इस्तेमाल किए गए रेगेक्स इंजन पर, कई विकल्प हैं। यहाँ दो हैं जो कई स्थितियों सहित अधिकांश स्थितियों पर लागू हो सकते हैं। मेरे विचार में, न तो s1|s2|s3|(whatYouWant)नुस्खा के रूप में लगभग आकर्षक है , अगर केवल इसलिए कि स्पष्टता हमेशा जीतती है।

1. बदलें तो मैच।

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

2. लुकरॉइड्स।

आपकी मूल पोस्ट से पता चला है कि आप समझते हैं कि लुकरॉइड्स का उपयोग करके किसी एकल शर्त को कैसे छोड़ना है। आपने कहा कि C # इसके लिए महान है, और आप सही हैं, लेकिन यह एकमात्र विकल्प नहीं है। उदाहरण के लिए C #, VB.NET और Visual C ++ में पाए गए .NET regex फ्लेवर, साथ ही पायथन में regexबदलने के लिए अभी भी-प्रायोगिक मॉड्यूल re, केवल दो इंजन हैं जो मुझे पता है कि अनंत-चौड़ाई लुकअप का समर्थन करते हैं। इन उपकरणों के साथ, एक लुकबाइंड में एक स्थिति न केवल पीछे बल्कि मैच पर और मैच से परे देखने का ध्यान रख सकती है, एक लुकहेड के साथ समन्वय करने की आवश्यकता से बचती है। अधिक शर्तें? और अधिक लुक।

सी # में s3 के लिए आपके पास regex को रीसायकल करने से पूरा पैटर्न इस तरह दिखेगा।

(?!.*\.)(?<!\([^()]*(?=\d+[^)]*\)))(?<!if\(\D*(?=\d+.*?//endif))\b\d+\b

लेकिन अब तक आप जानते हैं कि मैं इसकी सिफारिश नहीं कर रहा हूँ, है ना?

हटाए

@ HamZa और @Jerry ने सुझाव दिया है कि मैं उन मामलों के लिए एक अतिरिक्त चाल का उल्लेख करता हूं जब आप बस हटाना चाहते हैं WhatYouWant। आपको याद है कि मैच के लिए नुस्खा WhatYouWant(ग्रुप 1 में कैप्चर करना) था s1|s2|s3|(WhatYouWant), है ना? के सभी उदाहरण को हटाने के लिए WhatYouWant, आप regex को बदल देते हैं

(s1|s2|s3)|WhatYouWant

प्रतिस्थापन स्ट्रिंग के लिए, आप उपयोग करते हैं $1। यहाँ क्या होता है कि प्रत्येक उदाहरण के s1|s2|s3लिए मिलान किया जाता है, प्रतिस्थापन $1उस उदाहरण को स्वयं के साथ बदल देता है (द्वारा संदर्भित $1)। दूसरी ओर, जब WhatYouWantमिलान किया जाता है, तो इसे एक खाली समूह द्वारा बदल दिया जाता है और कुछ नहीं - और इसलिए हटा दिया जाता है। इस अद्भुत दृश्य के सुझाव के लिए यह डेमो देखें , @ HamZa और @Jerry धन्यवाद।

प्रतिस्थापन

यह हमें प्रतिस्थापन में लाता है, जिस पर मैं संक्षेप में स्पर्श करूंगा।

1. कुछ नहीं के साथ प्रतिस्थापित करते समय, ऊपर "हटाएं" चाल देखें।
2. प्रतिस्थापित करते समय, यदि पर्ल या पीसीआरई का उपयोग किया जाता है, तो (*SKIP)(*F)ऊपर उल्लिखित भिन्नता का उपयोग ठीक उसी तरह से करें जैसा आप चाहते हैं, और सीधे प्रतिस्थापन करें।
3. अन्य फ्लेवर में, रिप्लेसमेंट फंक्शन कॉल के भीतर, कॉलबैक या लैम्ब्डा का उपयोग करके मैच का निरीक्षण करें, और यह बदलें कि क्या ग्रुप 1 सेट है। यदि आपको इसकी सहायता की आवश्यकता है, तो पहले से संदर्भित लेख आपको विभिन्न भाषाओं में कोड देगा।

मज़े करो!

नहीं, रुको, और भी है!

आह, नाह, मैं बीस संस्मरणों में अपने संस्मरणों के लिए, अगले वसंत को रिलीज़ होने के लिए बचत करूँगा।

Comments

@ कोबी दो-भाग उत्तर। हां, कल रात लिखना छोड़ दिया और नीचे लिखा कि मैं इस पर सोऊंगा और बाद में साफ-सुथरा रहूंगा। :) हाँ चाल सरल है, लेकिन मैं आपकी धारणा को साझा नहीं करता कि यह "बुनियादी" है क्योंकि यह उन सामान्य साधनों का हिस्सा नहीं लगता जिन्हें लोग अपवर्जन समस्याओं को हल करने के लिए उपयोग करते हैं। जब मैंने एसओ पर "छोड़कर" या "जब तक" या "अंदर नहीं" समस्याओं के लिए गुगली की, तो केवल एक ही जवाब (बिना किसी वोट के) ने यह सुझाव दिया, दूसरों में से किसी ने भी नहीं किया। मैंने आपके उत्तर नहीं देखे हैं, वैसे, जो बहुत अच्छे हैं। :)

— zx81

क्षमा करें, लेकिन रेक्स की "सर्वश्रेष्ठ चाल" बस काम नहीं करती है ( मज़बूती से )। कहते हैं कि आप मैच करना चाहते हैं Tarzan, लेकिन नहीं जब डबल कोट्स के अंदर। : /no|no|(yes)/ट्रिक रेगेक्स कुछ इस तरह होगा: /"[^"]*"|Tarzan/(भागे हुए अक्षरों को अनदेखा करना)। यह कई मामलों के लिए काम करेगा, लेकिन निम्न मान्य जावास्क्रिप्ट पाठ पर लागू होने पर पूरी तरह से विफल हो जाता है var bug1 = 'One " quote here. Should match this Tarzan'; var bug2 = "Should not match this Tarzan";:। रेक्स की चाल केवल तभी काम करती है जब सभी संभव संरचनाएं मेल खाती हैं - दूसरे शब्दों में - आपको 100% सटीकता की गारंटी के लिए पाठ को पूरी तरह से पार्स करने की आवश्यकता है।

— सवार जूआन

क्षमा करें, अगर मैंने कठोर आवाज लगाई - तो निश्चित रूप से मेरा इरादा नहीं था। मेरा कहना है (जैसा कि ऊपर दिए गए मूल प्रश्न में मेरी दूसरी टिप्पणी में) यह है कि एक सही समाधान खोजे जा रहे लक्ष्य पाठ पर अत्यधिक निर्भर है। मेरे उदाहरण में लक्ष्य पाठ के रूप में जावास्क्रिप्ट स्रोत कोड है जिसमें एक एकल उद्धृत स्ट्रिंग के भीतर एक डबल उद्धरण है। यह आसानी से एक शाब्दिक RegExp हो सकता है जैसे: var bug1 = /"[^"]*"|(Tarzan)/gi;और इसका एक ही प्रभाव था (और यह दूसरा उदाहरण निश्चित रूप से एक किनारे नहीं है)। ऐसे कई और उदाहरण हैं जिनका मैं हवाला दे सकता हूं कि यह तकनीक मज़बूती से काम करने में विफल है।

— 3

@ridgerunner मुझे हमेशा आप से सुनने में मज़ा आता है, यह सिर्फ मेरे लिए अन्यायपूर्ण लगता है। जब हम जानते हैं कि हमारे तार में "झूठे अलर्ट" हो सकते हैं, तो हम सभी अपने पैटर्न को समायोजित करते हैं। उदाहरण के लिए, एक स्ट्रिंग से मिलान करने के लिए जो बच गए उद्धरण शामिल हो सकते हैं जो एक स्ट्रिंग मिलानक को फेंक सकते हैं, आप का उपयोग कर सकते हैं (?<!\\)"(?:\\"|[^"\r\n])*+" जब तक कि आपके पास कोई कारण न हो तब तक बड़ी बंदूकें न खींचें। समाधान का सिद्धांत अभी भी मान्य है। यदि हम बाईं ओर रखने के लिए एक पैटर्न व्यक्त करने में सक्षम नहीं हैं, तो यह एक अलग कहानी है, हमें एक अलग समाधान की आवश्यकता है। लेकिन समाधान वह करता है जो वह विज्ञापित करता है।

— zx81

यह उत्तर उपयोगकर्ता @funkwurm द्वारा स्टैक ओवरफ्लो रेगुलर एक्सप्रेशंस FAQ में जोड़ा गया है ।

— एलिटाल्मिंड

Answer 2

तीन अलग-अलग मैच करें और इन-प्रोग्राम सशर्त तर्क का उपयोग करके तीन स्थितियों के संयोजन को संभालें। आपको एक विशाल रेगेक्स में सब कुछ संभालने की आवश्यकता नहीं है।

संपादित करें: मुझे थोड़ा विस्तार दें क्योंकि प्रश्न अभी और रोचक बना है :-)

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

using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

public class MatcherWithExceptions {
  private string m_searchStr;
  private Regex m_searchRegex;
  private IEnumerable<Regex> m_exceptionRegexes;

  public string SearchString {
    get { return m_searchStr; }
    set {
      m_searchStr = value;
      m_searchRegex = new Regex(value);
    }
  }

  public string[] ExceptionStrings {
    set { m_exceptionRegexes = from es in value select new Regex(es); }
  }

  public bool IsMatch(string testStr) {
    return (
      m_searchRegex.IsMatch(testStr)
      && !m_exceptionRegexes.Any(er => er.IsMatch(testStr))
    );
  }
}

public class App {
  public static void Main() {
    var mwe = new MatcherWithExceptions();

    // Set up the matcher object.
    mwe.SearchString = @"\b\d{5}\b";
    mwe.ExceptionStrings = new string[] {
      @"\.$"
    , @"\(.*" + mwe.SearchString + @".*\)"
    , @"if\(.*" + mwe.SearchString + @".*//endif"
    };

    var testStrs = new string[] {
      "1." // False
    , "11111." // False
    , "(11111)" // False
    , "if(11111//endif" // False
    , "if(11111" // True
    , "11111" // True
    };

    // Perform the tests.
    foreach (var ts in testStrs) {
      System.Console.WriteLine(mwe.IsMatch(ts));
    }
  }
}

तो ऊपर, हम खोज स्ट्रिंग (पांच अंक), कई अपवाद तार (आपके s1 , s2 और s3 ) सेट करते हैं, और फिर कई परीक्षण स्ट्रिंग के खिलाफ मिलान करने का प्रयास करते हैं। मुद्रित परिणाम प्रत्येक परीक्षण स्ट्रिंग के बगल में टिप्पणियों में दिखाए जाने चाहिए।

Comments

आप शायद एक पंक्ति में तीन regex मैच पसंद है? Regex 1 स्थिति को समाप्त 1 (शायद सिर्फ खराब अंक हटाएं), r2 निकालें s2, r3 हटाएं s3 और मैचों के अंक बचे हैं? यह दिलचस्प विचार है।

— हैंस शिंडलर

हा, यकीन है, यही कारण है कि मैंने तुम्हें उकसाया। :) मुझे गलत मत समझो, मुझे अभी भी लगता है कि इस विशेष मामले में मेरा जवाब अधिक कुशल और बनाए रखने योग्य है। क्या आपने कल जोड़े गए मुक्त-रिक्ति संस्करण को देखा है? यह एक-पास और असाधारण रूप से पढ़ने और बनाए रखने में आसान है। लेकिन मुझे आपका काम और आपका विस्तारित जवाब पसंद है। क्षमा करें, मैं फिर से उत्थान नहीं कर सकता, अन्यथा मैं करता। :)

— zx81

Answer 3

आपकी आवश्यकता है कि यह सभी मामलों के लिए असंभव करने में असंभव के अंदर नहीं है। अर्थात्, यदि आप किसी तरह (से बाईं ओर और )दाईं ओर पा सकते हैं, तो इसका मतलब यह नहीं है कि आप परेंस के अंदर हैं। उदाहरण के लिए।

(....) + 55555 + (.....)- अंदर के परनों में अभी तक नहीं हैं (और )बाएं और दाएं हैं

अब आप अपने आप को चतुर समझ सकते हैं और (बाईं ओर देख सकते हैं, यदि आप )पहले मुठभेड़ नहीं करते हैं और ठीक इसके विपरीत। यह इस मामले के लिए काम नहीं करेगा:

((.....) + 55555 + (.....))- अंदर के परनों के बावजूद बंद )और (बाएं और दाएं होते हैं।

यह पता लगाना असंभव है कि क्या आप रेगेक्स का उपयोग करते हुए अंदर हैं, क्योंकि रेगेक्स गिन नहीं सकता है कि कितने पराग खोले गए हैं और कितने बंद हैं।

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

Comments

नेस्टेड कोष्ठक के बारे में किसी ने कुछ नहीं कहा, और आपका मामला # 1 zx81 के जवाब से ठीक है।

— डैन बेचर

अच्छे विचारों के लिए धन्यवाद :) लेकिन नेस्टेड कोष्ठक मुझे परेशान नहीं करता है इस प्रश्न के लिए यह बुरी स्थितियों के विचार के बारे में अधिक है s1 s2 s3

— हंस शिंडलर

बेशक यह असंभव नहीं है! यही कारण है कि आपको वर्तमान में पार्स के स्तर को ट्रैक करने की आवश्यकता होगी जिसमें आप पार्स कर रहे हैं।

— MrWonderful

यदि आप सीएफजी को किसी तरह से पार्स कर रहे हैं, जैसे कि ओपी लगता है, तो आपको एक एलएएलआर या इसी तरह के पार्सर उत्पन्न करके बेहतर सेवा प्रदान की जाती है, जिसमें इसके साथ कोई समस्या नहीं है।

— रोकल

Answer 4

हंस अगर आपको कोई आपत्ति नहीं है तो मैंने आपके पड़ोसी की वॉशिंग मशीन का उपयोग किया है जिसे पर्ल कहा जाता है :)

संपादित: नीचे एक छद्म कोड:

  loop through input
  if line contains 'if(' set skip=true
        if skip= true do nothing
        else
           if line match '\b\d{5}\b' set s0=true
           if line does not match s1 condition  set s1=true
           if line does not match s2 condition  set s2=true
           if s0,s1,s2 are true print line 
  if line contains '//endif' set skip=false

फ़ाइल input.txt को देखते हुए:

tiago@dell:~$ cat input.txt 
this is a text
it should match 12345
if(
it should not match 12345
//endif 
it should match 12345
it should not match 12345.
it should not match ( blabla 12345  blablabla )
it should not match ( 12345 )
it should match 12345

और स्क्रिप्ट validator.pl:

tiago@dell:~$ cat validator.pl 
#! /usr/bin/perl
use warnings;
use strict;
use Data::Dumper;

sub validate_s0 {
    my $line = $_[0];
    if ( $line =~ \d{5/ ){
        return "true";
    }
    return "false";
}

sub validate_s1 {
    my $line = $_[0];
    if ( $line =~ /\.$/ ){
        return "false";
    }
    return "true";
}

sub validate_s2 {
    my $line = $_[0];
    if ( $line =~ /.*?\(.*\d{5.*?\).*/ ){
        return "false";
    }
    return "true";
}

my $skip = "false";
while (<>){
    my $line = $_; 

    if( $line =~ /if\(/ ){
       $skip = "true";  
    }

    if ( $skip eq "false" ) {
        my $s0_status = validate_s0 "$line"; 
        my $s1_status = validate_s1 "$line";
        my $s2_status = validate_s2 "$line";

        if ( $s0_status eq "true"){
            if ( $s1_status eq "true"){
                if ( $s2_status eq "true"){
                    print "$line";
                }
            }
        }
    } 

    if ( $line =~ /\/\/endif/) {
        $skip="false";
    }
}

निष्पादन:

tiago @ dell: ~ $ कैट input.txt | perl validator.pl
यह 12345 से मेल खाना चाहिए
यह 12345 से मेल खाना चाहिए
यह 12345 से मेल खाना चाहिए

Answer 5

यकीन नहीं होता कि इससे आपको मदद मिलेगी या नहीं, लेकिन मैं निम्नलिखित मान्यताओं पर विचार कर एक समाधान प्रदान कर रहा हूं -

1. आपको सभी स्थितियों की जांच करने के लिए एक सुरुचिपूर्ण समाधान की आवश्यकता है
2. भविष्य में और कभी भी स्थितियां बदल सकती हैं।
3. एक शर्त दूसरों पर निर्भर नहीं होनी चाहिए।

हालाँकि मैंने निम्नलिखित पर भी विचार किया -

1. दी गई फ़ाइल में न्यूनतम त्रुटियां हैं। यदि यह काम करता है तो मेरे कोड को इससे निपटने के लिए कुछ संशोधनों की आवश्यकता हो सकती है।
2. मैंने if(ब्लॉक का ट्रैक रखने के लिए स्टैक का इस्तेमाल किया ।

ठीक है यहाँ समाधान है -

मैंने विन्यास योग्य पार्सर को लागू करने के लिए C # और इसके साथ MEF (Microsoft एक्स्टेंसिबिलिटी फ्रेमवर्क) का उपयोग किया। विचार यह है, पंक्ति को मान्य करने और सत्यापन के आधार पर सही या गलत लौटने के लिए पार्स करने के लिए एकल पार्सर और विन्यास योग्य सत्यापनकर्ता वर्गों की एक सूची का उपयोग करें। फिर आप किसी भी सत्यापनकर्ता को कभी भी जोड़ या हटा सकते हैं या यदि आप चाहें तो नए जोड़ सकते हैं। अब तक मैंने आपके द्वारा उल्लिखित S1, S2 और S3 के लिए पहले से ही लागू कर दिया है, बिंदु 3 पर कक्षाओं की जांच करें। आपको भविष्य में आवश्यकता होने पर s4, s5 के लिए कक्षाएं जोड़ना होगा।

1. सबसे पहले, इंटरफेस बनाएँ -

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   
   namespace FileParserDemo.Contracts
   {
       public interface IParser
       {
           String[] GetMatchedLines(String filename);
       }
   
       public interface IPatternMatcher
       {
           Boolean IsMatched(String line, Stack<string> stack);
       }
   }

2. फिर फाइल रीडर और चेकर आता है -

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using FileParserDemo.Contracts;
   using System.ComponentModel.Composition.Hosting;
   using System.ComponentModel.Composition;
   using System.IO;
   using System.Collections;
   
   namespace FileParserDemo.Parsers
   {
       public class Parser : IParser
       {
           [ImportMany]
           IEnumerable<Lazy<IPatternMatcher>> parsers;
           private CompositionContainer _container;
   
           public void ComposeParts()
           {
               var catalog = new AggregateCatalog();
               catalog.Catalogs.Add(new AssemblyCatalog(typeof(IParser).Assembly));
               _container = new CompositionContainer(catalog);
               try
               {
                   this._container.ComposeParts(this);
               }
               catch
               {
   
               }
           }
   
           public String[] GetMatchedLines(String filename)
           {
               var matched = new List<String>();
               var stack = new Stack<string>();
               using (StreamReader sr = File.OpenText(filename))
               {
                   String line = "";
                   while (!sr.EndOfStream)
                   {
                       line = sr.ReadLine();
                       var m = true;
                       foreach(var matcher in this.parsers){
                           m = m && matcher.Value.IsMatched(line, stack);
                       }
                       if (m)
                       {
                           matched.Add(line);
                       }
                    }
               }
               return matched.ToArray();
           }
       }
   }

3. फिर अलग-अलग चेकर्स के कार्यान्वयन की बात आती है, वर्ग के नाम स्वयं व्याख्यात्मक हैं, इसलिए मुझे नहीं लगता कि उन्हें अधिक विवरणों की आवश्यकता है।

   using FileParserDemo.Contracts;
   using System;
   using System.Collections.Generic;
   using System.ComponentModel.Composition;
   using System.Linq;
   using System.Text;
   using System.Text.RegularExpressions;
   using System.Threading.Tasks;
   
   namespace FileParserDemo.PatternMatchers
   {
       [Export(typeof(IPatternMatcher))]
       public class MatchAllNumbers : IPatternMatcher
       {
           public Boolean IsMatched(String line, Stack<string> stack)
           {
               var regex = new Regex("\\d+");
               return regex.IsMatch(line);
           }
       }
   
       [Export(typeof(IPatternMatcher))]
       public class RemoveIfBlock : IPatternMatcher
       {
           public Boolean IsMatched(String line, Stack<string> stack)
           {
               var regex = new Regex("if\\(");
               if (regex.IsMatch(line))
               {
                   foreach (var m in regex.Matches(line))
                   {
                       //push the if
                       stack.Push(m.ToString());
                   }
                   //ignore current line, and will validate on next line with stack
                   return true;
               }
               regex = new Regex("//endif");
               if (regex.IsMatch(line))
               {
                   foreach (var m in regex.Matches(line))
                   {
                       stack.Pop();
                   }
               }
               return stack.Count == 0; //if stack has an item then ignoring this block
           }
       }
   
       [Export(typeof(IPatternMatcher))]
       public class RemoveWithEndPeriod : IPatternMatcher
       {
           public Boolean IsMatched(String line, Stack<string> stack)
           {
               var regex = new Regex("(?m)(?!\\d+.*?\\.$)\\d+");
               return regex.IsMatch(line);
           }
       }
   
   
       [Export(typeof(IPatternMatcher))]
       public class RemoveWithInParenthesis : IPatternMatcher
       {
           public Boolean IsMatched(String line, Stack<string> stack)
           {
               var regex = new Regex("\\(.*\\d+.*\\)");
               return !regex.IsMatch(line);
           }
       }
   }

4. कार्यक्रम -

   using FileParserDemo.Contracts;
   using FileParserDemo.Parsers;
   using System;
   using System.Collections.Generic;
   using System.ComponentModel.Composition;
   using System.IO;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   
   namespace FileParserDemo
   {
       class Program
       {
           static void Main(string[] args)
           {
               var parser = new Parser();
               parser.ComposeParts();
               var matches = parser.GetMatchedLines(Path.GetFullPath("test.txt"));
               foreach (var s in matches)
               {
                   Console.WriteLine(s);
               }
               Console.ReadLine();
           }
       }
   }

परीक्षण के लिए मैंने @ टियागो के नमूने की फाइल ली Test.txtजिसमें निम्न पंक्तियाँ थीं -

this is a text
it should match 12345
if(
it should not match 12345
//endif 
it should match 12345
it should not match 12345.
it should not match ( blabla 12345  blablabla )
it should not match ( 12345 )
it should match 12345

आउटपुट देता है -

it should match 12345
it should match 12345
it should match 12345

पता नहीं यह आपकी मदद करेगा या नहीं, मुझे इसके साथ खेलने में एक मजेदार समय था .... :)

इसके साथ सबसे अच्छी बात यह है कि, एक नई शर्त जोड़ने के लिए आपको जो कुछ भी करना है IPatternMatcher, उसका कार्यान्वयन प्रदान करना है , यह स्वचालित रूप से कहा जाएगा और इस प्रकार मान्य होगा।

Answer 6

@ Zx81 के रूप में समान है, (*SKIP)(*F)लेकिन एक नकारात्मक रूपांतर दावे का उपयोग करने के साथ।

(?m)(?:if\(.*?\/\/endif|\([^()]*\))(*SKIP)(*F)|\b\d+\b(?!.*\.$)

डेमो

अजगर में, मैं आसानी से इस तरह करना होगा,

import re
string = """cat 123 sat.
I like 000 not (456) though 111 is fine
222 if(  //endif if(cat==789 stuff  //endif   333"""
for line in string.split('\n'):                                  # Split the input according to the `\n` character and then iterate over the parts.
    if not line.endswith('.'):                                   # Don't consider the part which ends with a dot.
        for i in re.split(r'\([^()]*\)|if\(.*?//endif', line):   # Again split the part by brackets or if condition which endswith `//endif` and then iterate over the inner parts.
            for j in re.findall(r'\b\d+\b', i):                  # Then find all the numbers which are present inside the inner parts and then loop through the fetched numbers.
                print(j)                                         # Prints the number one ny one.

आउटपुट:

000
111
222
333