रुबी रेगेक्सपी: एकल और यूनियन के बीच एक एकल regexp

Question

के बीच अंतर मैंने उदाहरणों को सरल बना दिया है। मान लें कि मेरे पास एक स्ट्रिंग के लिए कोड युक्त एक स्ट्रिंग है। मैं एक शाब्दिक बिंदु का मिलान करने के लिए regex चाहते हैं और इस तरह मैं इसे होना चाहते हैं:

\. 

तो मैं निम्नलिखित रूबी स्ट्रिंग बनाने के लिए:

"\\." 

लेकिन जब मैं करने के लिए Regexp.union के साथ उपयोग करें

irb(main):017:0> Regexp.union("\\.") 
=> /\\\./ 

कि एक स्लेश एक बिंदु ही नहीं, एक भी डॉट के बाद मिलान हो जाएगा: मेरी regex बनाने के लिए, मैं इस मिलता है। यह करने के लिए पिछले परिणाम की तुलना करें:

irb(main):018:0> Regexp.new("\\.") 
=> /\./ 

जो लेकिन Regexp मैं चाहता हूँ देता जरूरत संघ के बिना।

क्या आप समझा सकते हैं कि रूबी इस तरह क्यों कार्य करती है और रेगेक्स के सही संघ को कैसे बनाते हैं? उपयोग का संदर्भ रेज़ेक्स का वर्णन करने वाले जेएसओएन तारों को आयात करने और रूबी में उन्हें संघबद्ध करने का है।

Answer 1

Regexp.union पर एक स्ट्रिंग पास करने के लिए सचमुच उस स्ट्रिंग से मेल खाने के लिए डिज़ाइन किया गया है। इसे बचने की कोई आवश्यकता नहीं है, Regexp.escape पहले ही आंतरिक रूप से बुलाया जा चुका है।

Regexp.union(".") 
#=> /\./ 

आप, Regexp.union को नियमित अभिव्यक्ति पारित करने के लिए तार का उपयोग नहीं करना चाहते हैं:

Regexp.union(Regexp.new("\\.")) 
#=> /\./ 

Answer 2

\\. अब आप एक \ और \. और पहले एक बच रहा है है, जहां आप गलत मुझे लगता है कि चला गया है आप एक . तुम सिर्फ पहले एक \. का उपयोग करना चाहिए मिलान करना चाहते हैं।

सिर्फ रूबी द्वारा प्रदान की मानक regex जो अपने मामले

में Regexp.new /\./ होगा तुम सिर्फ Regexp.union "." का उपयोग यूनियन उपयोग करना चाहते हैं का उपयोग सुरक्षा के लिए जो लौट जाना /\./

माणिक regex वर्ग से:

Regexp.union("a+b*c")    #=> /a\+b\*c/