Julia Language
regexes

वाक्य - विन्यास

• Regex ( "[regex]")
• आर "[regex]"
• मैच (सुई, हैस्टैक)
• मैटल (सुई, हैस्टैक)
• प्रत्येक (सुई, हैस्टैक)
• इस्मैच (सुई, हैस्टैक)

पैरामीटर

रेगेक्स शाब्दिक

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

कंस्ट्रक्टर का उपयोग करके स्ट्रिंग से Regex बनाना संभव है:

julia> Regex("(cat|dog)s?")

लेकिन सुविधा और आसानी से भागने के लिए, इसके बजाय @r_str स्ट्रिंग मैक्रो का उपयोग किया जा सकता है:

julia> r"(cat|dog)s?"

¹ : तकनीकी रूप से, जूलिया रीगेक्स का समर्थन करता है, जो भाषा सिद्धांत में नियमित अभिव्यक्ति कहे जाने वाले की तुलना में अलग और अधिक शक्तिशाली हैं। अक्सर, "रेगुलर एक्सप्रेशन" शब्द का इस्तेमाल रीगेक्स को भी संदर्भित करने के लिए किया जाएगा।

मैच ढूंढना

नियमित अभिव्यक्तियों के लिए चार प्राथमिक उपयोगी कार्य हैं, जिनमें से सभी needle, haystack ऑर्डर में तर्क लेते हैं। शब्दावली "सुई" और "हैस्टैक" अंग्रेजी मुहावरे से आती है "एक घास में सुई ढूंढना"। रेगेक्स के संदर्भ में, रेगेक्स सुई है, और पाठ हिस्टैक है।

match फ़ंक्शन का उपयोग स्ट्रिंग में पहला मैच खोजने के लिए किया जा सकता है:

julia> match(r"(cat|dog)s?", "my cats are dogs")
RegexMatch("cats", 1="cat")

matchall फ़ंक्शन का उपयोग स्ट्रिंग में एक नियमित अभिव्यक्ति के सभी मैचों को खोजने के लिए किया जा सकता है:

julia> matchall(r"(cat|dog)s?", "The cat jumped over the dogs.")
2-element Array{SubString{String},1}:
 "cat" 
 "dogs"

ismatch फ़ंक्शन एक बूलियन देता है जो दर्शाता है कि क्या स्ट्रिंग के अंदर एक मैच पाया गया था:

julia> ismatch(r"(cat|dog)s?", "My pigs")
false

julia> ismatch(r"(cat|dog)s?", "My cats")
true

प्रत्‍येक समारोह RegexMatch वस्‍तुओं पर एक eachmatch देता है, लूप के लिए उपयोग के for उपयुक्त है :

julia> for m in eachmatch(r"(cat|dog)s?", "My cats and my dog")
           println("Matched $(m.match) at index $(m.offset)")
       end
Matched cats at index 4
Matched dog at index 16

समूहों पर कब्जा

कैप्चरिंग समूहों द्वारा कैप्चर किए गए RegexMatch को RegexMatch संकेतन का उपयोग करके RegexMatch ऑब्जेक्ट्स से एक्सेस किया जा सकता है।

उदाहरण के लिए, निम्नलिखित रेगेक्स ने उत्तर अमेरिकी फोन नंबर (555)-555-5555 प्रारूप में लिखे हैं:

julia> phone = r"\((\d{3})\)-(\d{3})-(\d{4})"

और मान लें कि हम किसी पाठ से फ़ोन नंबर निकालना चाहते हैं:

julia> text = """
       My phone number is (555)-505-1000.
       Her phone number is (555)-999-9999.
       """
"My phone number is (555)-505-1000.\nHer phone number is (555)-999-9999.\n"

matchall फ़ंक्शन का उपयोग करके, हम स्वयं से मिलान किए गए सबस्ट्रिंग्स का एक सरणी प्राप्त कर सकते हैं:

julia> matchall(phone, text)
2-element Array{SubString{String},1}:
 "(555)-505-1000"
 "(555)-999-9999"

लेकिन मान लीजिए कि हम क्षेत्र कोड (पहले तीन अंक, कोष्ठक में संलग्न) का उपयोग करना चाहते हैं। तब हम प्रत्येक eachmatch उपयोग कर सकते हैं:

julia> for m in eachmatch(phone, text)
           println("Matched $(m.match) with area code $(m[1])")
       end
Matched (555)-505-1000 with area code 555
Matched (555)-999-9999 with area code 555

यहाँ ध्यान दें कि हम m[1] उपयोग करते हैं क्योंकि क्षेत्र कोड हमारी नियमित अभिव्यक्ति में पहला कैप्चर समूह है। हम एक फ़ंक्शन का उपयोग करके फ़ोन नंबर के सभी तीन घटकों को एक ट्यूपल के रूप में प्राप्त कर सकते हैं:

julia> splitmatch(m) = m[1], m[2], m[3]
splitmatch (generic function with 1 method)

तो हम एक विशेष RegexMatch लिए इस तरह के एक समारोह लागू कर सकते हैं:

julia> splitmatch(match(phone, text))
("555","505","1000")

या फिर हम सकता map यह प्रत्येक मैच के पार:

julia> map(splitmatch, eachmatch(phone, text))
2-element Array{Tuple{SubString{String},SubString{String},SubString{String}},1}:
 ("555","505","1000")
 ("555","999","9999")