रूबी में नियमित अभिव्यक्ति का उपयोग करना

नियमित अभिव्यक्ति कुछ के लिए सभी परेशानियों से मुक्ति है और अन्य डेवलपर्स के लिए एक बुरा सपना है, और यदि निष्पक्ष रूप से बात करें, तो यह एक शक्तिशाली उपकरण है जिसके लिए आवेदन में बहुत सावधानी की आवश्यकता होती है। रूबी की नियमित अभिव्यक्तियाँ (regexes, regexps, regulars) पर्ल 5 वाक्यविन्यास पर आधारित हैं और इसलिए उन सभी से परिचित हैं जिन्होंने पर्ल, पायथन या पीएचपी का उपयोग किया है। लेकिन रूबी अच्छा है क्योंकि भाषा के प्रत्येक घटक को अपने स्वयं के दृष्टिकोण के साथ लागू किया जाता है, इस उपकरण के उपयोग को सरल करता है और इसकी शक्ति को बढ़ाता है। अपने छोटे लेख में, मैं रूबी में नियमित रूप से सुविधाओं और विभिन्न ऑपरेटरों में उनके आवेदन पर चर्चा करता हूं।

रूबी में, सब कुछ एक वस्तु है

सबसे पहले, यह ध्यान देने योग्य है कि नियमित अभिव्यक्ति संबंधित वर्ग की एक वस्तु है। तदनुसार, इसे कॉल टू न्यू और मर्ज (संघ) के माध्यम से बनाया जा सकता है।

r1 = Regexp.new “a” r2 = Regexp.new “b” ru = Regexp.union r1, r2 

संघ से उत्पन्न अभिव्यक्ति कम से कम एक सम्मिलित टेम्प्लेट के अनुरूप होगी।

नियमित-स्ट्रिंग मिलान ऑपरेटर पहले मैच या शून्य का सूचकांक लौटाता है, लेकिन कई मामलों में हमें मिल रहे मैच के बारे में अन्य जानकारी की आवश्यकता होती है। आप पर्ल की तरह, विशेष चर, $ ~, $ ', $ &, आदि का उपयोग कर सकते हैं। यदि चर $ 1, $ 2, ... समूहों के अनुरूप याद रखना काफी आसान है, तो आमतौर पर लोग दूसरों का उपयोग कैसे करते हैं, यह हमेशा मेरे लिए एक रहस्य बना हुआ है। इसलिए, रूबी में, ज़ाहिर है, एक और दृष्टिकोण है - आप Regexp.last_match विधि का उपयोग कर सकते हैं

 “abcde” =~ /(b)(c)(d)/ Regexp.last_match[0] # "asd" Regexp.last_match[1] # "b" Regexp.last_match[2] # "c" Regexp.last_match[3] # "d" Regexp.last_match.pre_match # "a" Regexp.last_match.post_match # "e" 

नामित समूह

संस्करण 1.9 के साथ शुरू, रूबी नामित समूहों के वाक्यविन्यास का समर्थन करता है:

 "a reverse b".gsub /(?<first>\w+) reverse (?<second>\w+)/, '\k<second> \k<first>' # “ba” 

एक ही उदाहरण बैकलिंक्स के उपयोग को दर्शाता है, लेकिन यह सुविधा पहले से ही सभी आधुनिक पीसीआरई कार्यान्वयन में मौजूद है।

\ k <group_name> - यह विशेष अनुक्रम अनिवार्य रूप से नामित समूहों के लिए बैकलिंक्स का एक एनालॉग है।
\ g <group_name> पहले निर्दिष्ट नामित समूह की पुनरावृत्ति के अनुरूप अनुक्रम है। उनके बीच का अंतर केवल एक उदाहरण का उपयोग करके दिखाया गया है:

 "1 1" =~ /(?<first>\d+) \k<first>/ # 0 "1 2" =~ /(?<first>\d+) \k<first>/ #nil "1 a" =~ /(?<first>\d+) \k<first>/ #nil "1 1" =~ /(?<first>\d+) \g<first>/ # 0 "1 2" =~ /(?<first>\d+) \g<first>/ # 0 "1 a" =~ /(?<first>\d+) \g<first>/ #nil 

आप इन समूहों के साथ मैचडाटा ऑब्जेक्ट के माध्यम से मैच भी प्राप्त कर सकते हैं:

 Regexp.last_match[:first] 

अनुपालन की जांच करने के अन्य तरीके

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

 "abcde"[/bc?f?/] # "bc" 

साथ ही स्लाइस विधि:

 "abcde".slice(/bc?f?/) # "bc" 

इसके अलावा, एक और है, प्रतीत होता है कि सबसे तार्किक तरीका नहीं है:

 /bc?f?/ === "abcde" # true 

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

विभिन्न कार्यों में नियमित का उपयोग

रूबी में नियमित अभिव्यक्ति के सबसे उपयोगी अनुप्रयोगों में से एक, जो हालांकि इतना सामान्य नहीं है, केस स्टेटमेंट में उनका उपयोग है। एक उदाहरण:

 str = 'september' case str when /june|july|august/: puts "it's summer" when /september|october|november/: puts "it's autumn" end 

बात यह है कि मामले की तुलना केवल उपरोक्त ऑपरेटर === ( यहाँ अधिक विवरण) द्वारा की जाती है, जो हमें ऐसे मामलों में regexps का उपयोग बहुत ही सलीके और शान से करने की अनुमति देता है।

विभाजन समारोह में नियमित रूप से भी इस्तेमाल किया जा सकता है। रूबी-डॉक्टर के साथ उदाहरण:

 "1, 2.34,56, 7".split(%r{,\s*}) # ["1", "2.34", "56", "7"] 

इस फ़ंक्शन का उपयोग करके स्ट्रिंग से शब्दों की सूची प्राप्त करने का एक तरीका:

 “one two three”.split(/\W+/) 

सिरिलिक स्ट्रिंग्स के साथ काम करने के लिए:

 ",      ".split(/[^[:word:]]+/) # ["", "", "", "", "", "", ""] (ruby 1.9 only) 

स्ट्रिंग में भागों को विभाजित करने के लिए स्कैन विधि का उपयोग करना कभी-कभी बहुत अधिक सुविधाजनक होता है। इस विधि का उपयोग करके एक पिछला उदाहरण:

 ",      ".scan(/[[:word:]]+/) # ["", "", "", "", "", "", ""] (ruby 1.9 only) 

सब फ़ंक्शन, जो सबस्ट्रिंग की पहली घटना को प्रतिस्थापित करता है, एक इनपुट के रूप में रेगेक्सप ऑब्जेक्ट को भी स्वीकार कर सकता है:

 "today is september 25".sub(/\w+mber/, 'july') # "today is july 25" 

इसी तरह, आप उप में नियमित अभिव्यक्ति का उपयोग कर सकते हैं!, Gsub और gsub! .. विधियाँ।

विभाजन विधि, एक स्ट्रिंग को 3 भागों में विभाजित करती है, एक परिसीमनक के रूप में एक नियमित अभिव्यक्ति का उपयोग कर सकती है:

 "12:35".partition(/[:\.,]/) # ["12", ":", "35"] 

इसी तरह, आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं।

सूचकांक और रिंडेक्स विधियां भी नियमित रूप से काम कर सकती हैं, वे निश्चित रूप से, स्ट्रिंग में उनमें से पहली और आखिरी घटनाओं के सूचकांकों को वापस करते हैं।

आगे पढ़ रहे हैं

1. फ्रिल्ड - नियमित अभिव्यक्तियाँ
2. फलांगन, मात्सुमोतो - रूबी प्रोग्रामिंग लैंग्वेज
3. रूबी-डॉक्टर वर्ग रेगेक्स