रेगुलर एक्सप्रेशन चैटबॉट

रेगुलर एक्सप्रेशन स्ट्रिंग्स पर पैटर्न मैच करने का एक बहुत उपयोगी तरीका है। इसके लिए एक खास तरह की भाषा (DSL) बनाई गई है, जो सिर्फ इसी काम के लिए है।

कई दूसरी प्रोग्रामिंग भाषाओं की तरह Julia अपनी खुद की Regex लाइब्रेरी बनाने की कोशिश नहीं करती। इसके बजाय यह लोकप्रिय PCRE2 लाइब्रेरी को रैप करती है, जिससे इसका Regex सिंटैक्स (जैसे कि) Gleam जैसा ही और JavaScript से बहुत मिलता-जुलता बनता है।

• Regex101
• RegExr
• RexEgg
• RegexOne
• Regular Expressions Info

रेगुलर एक्सप्रेशन के लिए Julia का इंटरफेस मैनुअल में समझाया गया है।

Julia में रेगुलर एक्सप्रेशन बस एक स्ट्रिंग ही है, और उसके शुरू के " से पहले r लगाना होता है। इसकी सभी बुनियादी सुविधाएँ स्टैंडर्ड लाइब्रेरी में ही मौजूद हैं।

वास्तव में, Strings कॉन्सेप्ट में बताए गए कई फंक्शन पहले से ही Regex खोज के लिए बने हैं, जैसे occursin().

julia> re = r"test$"
r"test$"

julia> typeof(re)
Regex

# Does a string end with "test"?
julia> occursin(re, "this is a test")
true

julia> occursin(re, "these are tests")
false

क्लोज़िंग कोट के बाद मॉडिफायर अक्षर भी लग सकते हैं, जैसे i लगाने पर मैच में अक्षरों के बड़े-छोटे होने से फर्क नहीं पड़ता।

julia> occursin(r"test", "Testing")
false

julia> occursin(r"test"i, "Testing")
true

कैप्चर

आम तौर पर हमें यह जानना होता है कि क्या मैच हुआ। इसके लिए रेगुलर एक्सप्रेशन के अंदर गोल ब्रैकेटों में कैप्चर ग्रुप डाले जाते हैं, और फिर match() फंक्शन इस्तेमाल किया जाता है।

julia> m = match(r"(\d+g) .* (\d+ml)", "dissolve 25g sugar in 200ml water")
RegexMatch("25g sugar in 200ml", 1="25g", 2="200ml")

julia> m.captures
2-element Vector{Union{Nothing, SubString{String}}}:
 "25g"
 "200ml"

# how many matches?
julia> length(m.captures)
2

# what matched?
julia> m[1], m[2]
("25g", "200ml")

# Starting positions of the matches (character index)
julia> m.offsets
2-element Vector{Int64}:
 10
 23

ऐसा भी हो सकता है कि मैच न मिले। तब नतीजा RegexMatch की जगह खास वैल्यू Nothing होता है, इसलिए इसकी जाँच के लिए तैयार रहिए।

# failed match
m = match(r"(not here)", "dissolve 25g sugar in 200ml water")

julia> typeof(m)
Nothing

julia> isnothing(m)
true

हालाँकि match डिफॉल्ट रूप से स्ट्रिंग की शुरुआत से ढूँढना शुरू करता है, हम एक ऑफसेट n भी दे सकते हैं, जिससे पहले n अक्षर छोड़ दिए जाएँ।

# capture first match
julia> m = match(r"(\wat)", "cat, sat, mat")
RegexMatch("cat", 1="cat")

# ignore first 5 characters, then match
julia> m = match(r"(\wat)", "cat, sat, mat", 5)
RegexMatch("sat", 1="sat")

Julia में match() लक्ष्य स्ट्रिंग में सिर्फ पहला मैच ही ढूँढता है। कुछ दूसरी भाषाओं की तरह यहाँ कोई ग्लोबल मॉडिफायर नहीं होता।

इसके बजाय eachmatch() है, जो मैचों का इटरेटर लौटाता है। यह लेज़ी तरीके से चलता है, इसलिए आपको इसे अपनी ज़रूरत के फॉर्मेट में बदलना पड़ सकता है।

julia> matches = eachmatch(r"(\wat)", "cat, sat, mat")
Base.RegexMatchIterator{String}(r"(\wat)", "cat, sat, mat", false)

# convert to vector
julia> collect(matches)
3-element Vector{RegexMatch}:
 RegexMatch("cat", 1="cat")
 RegexMatch("sat", 1="sat")
 RegexMatch("mat", 1="mat")

# convert with comprehension
julia> [m.match for m in matches]
3-element Vector{SubString{String}}:
 "cat"
 "sat"
 "mat"

# broadcast an anonymous function
julia> (m -> m.match).(matches)
3-element Vector{SubString{String}}:
 "cat"
 "sat"
 "mat"

बदलना

Regex इस्तेमाल करने की एक आम वजह है मैच को किसी दूसरी स्ट्रिंग से बदल देना।

replace() फंक्शन के बारे में Strings कॉन्सेप्ट में बताया गया था, जहाँ खोजने के लिए स्ट्रिंग लिटरल इस्तेमाल होते हैं। यही फंक्शन Regex मैचिंग की पूरी शक्ति का फायदा उठा सकता है।

julia> replace("some string", r"[aeiou]" => "*")
"s*m* str*ng"

julia> replace("first second", r"(\w+) (?<agroup>\w+)" => s"\g<agroup> \1")
"second first"

ऊपर का दूसरा उदाहरण दिखाता है कि बदलाव में क्रमांकित और नाम वाले, दोनों तरह के कैप्चर ग्रुप कैसे इस्तेमाल किए जा सकते हैं, और यह सब s" " स्ट्रिंग के अंदर होता है।

ज़्यादा जानकारी के लिए मैनुअल देखिए। यह ऐसा विषय है जो ज़्यादातर प्रोग्रामरों को बार-बार डॉक्युमेंटेशन देखने पर मजबूर कर देता है!