जूलिया

Question

x = r"abc" 
y = r"def" 
z = join([x,y], "|") 

z # => r"r\"abc\"|r\"def\"" 

में नियमित अभिव्यक्ति में शामिल होने से वहाँ join का कोई तरीका है (और सामान्य में हेरफेर) Regex कि केवल रेगुलर एक्सप्रेशन से सामग्री के साथ संबंधित है (यानी r संशोधक का इलाज नहीं है जैसे कि यह सामग्री का हिस्सा है)। z के लिए वांछित आउटपुट है:

z # => r"abc|def" 

Answer 1

macro p_str(s) s end 
x = p"abc" 
y = p"def" 
z = Regex(join([x,y], "|")) 

r "बोली" ऑपरेटर वास्तव में जो समय लगता है आप के लिए एक नियमित अभिव्यक्ति संकलित करता है। यदि आपके पास नियमित अभिव्यक्ति के कुछ हिस्सों हैं जो आप एक बड़ा निर्माण करने के लिए उपयोग करना चाहते हैं तो आपको "नियमित उद्धरण" का उपयोग करके भागों को स्टोर करना चाहिए।

लेकिन आप "नियमित उद्धरण" बनाम आर "उद्धरण" के साथ प्राप्त स्केची से बचने वाले नियमों के बारे में क्या पूछते हैं? आप तुरंत एक नियमित अभिव्यक्ति संकलित करने के लिए अधूरा r "बोली" नियम नहीं बल्कि चाहते हैं तो आप की तरह एक मैक्रो का उपयोग कर सकते हैं:

macro p_str(s) s end 

अब आप एपी "बोली" है कि एक आर "बोली" की तरह निकल जाता है, लेकिन अभी एक स्ट्रिंग देता है।

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

         # "baked\nescape" -> baked\nescape 
macro p_mstr(s) s end     # p"""raw\nescape""" -> raw\\nescape 
macro dq_str(s) "\"" * s * "\"" end # dq"with quotes" -> "with quotes" 
macro sq_str(s) "'" * s * "'" end  # sq"with quotes" -> 'with quotes' 
macro s_mstr(s) strip(lstrip(s)) end # s""" "stripme" """-> "stripme" 

जब आप टुकड़े कर लें तो आप अपने में शामिल होने और की तरह एक regex बनाने के कर सकते हैं:

myre = Regex(join([x, y], "|")) 

वैसे ही जैसे आप सोचा।

आप क्या सदस्यों (जैसे Regex.pattern के रूप में) की कोशिश एक वस्तु है के बारे में अधिक जानने के लिए करना चाहते हैं:

julia> dump(r"pat") 
Regex 
    pattern: ASCIIString "pat" 
    options: Uint32 33564672 
    regex: Array(Uint8,(61,)) [0x45,0x52,0x43,0x50,0x3d,0x00,0x00,0x00,0x00,0x28 … 0x1d,0x70,0x1d,0x61,0x1d,0x74,0x72,0x00,0x09,0x00]