रेगुलर एक्सप्रेशन में

रेगुलर एक्सप्रेशन के बारे में

गो में रेगुलर एक्सप्रेशन के लिए regexp पैकेज सपोर्ट देता है।

सिंटैक्स

स्वीकार किए जाने वाले रेगुलर एक्सप्रेशन का सिंटैक्स वही सामान्य सिंटैक्स है जिसका इस्तेमाल Perl, Python और दूसरी भाषाएँ करती हैं।

खोज के पैटर्न और इनपुट टेक्स्ट, दोनों को UTF-8 के रूप में पढ़ा जाता है।

स्ट्रिंग बनाने के लिए जब बैकटिक (`) इस्तेमाल करते हैं, तो बैकस्लैश (\) का कोई खास मतलब नहीं रहता और वे टैब \t या नई लाइन \n जैसे खास अक्षरों की शुरुआत नहीं बताते:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

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

"\\" // string with a single backslash
`\\` // string with 2 backslashes

पैटर्न कंपाइल करना - RegExp टाइप

रेगुलर एक्सप्रेशन इस्तेमाल करने के लिए पहले हमें स्ट्रिंग पैटर्न कंपाइल करना होता है। यहाँ कंपाइल करने का मतलब है रेगुलर एक्सप्रेशन के स्ट्रिंग पैटर्न को लेकर उसे एक ऐसे आंतरिक रूप में बदल देना जिसके साथ काम करना आसान होता है। हमें हर पैटर्न को सिर्फ एक बार कंपाइल करना होता है। उसके बाद हम रेगुलर एक्सप्रेशन के कंपाइल किए हुए रूप का इस्तेमाल कई बार कर सकते हैं। regexp.Regexp टाइप एक कंपाइल किए गए रेगुलर एक्सप्रेशन को दर्शाता है। हम regexp.Compile फंक्शन की मदद से स्ट्रिंग पैटर्न को regexp.Regexp में कंपाइल कर सकते हैं। अगर कंपाइल करना नाकाम रहे, तो यह फंक्शन nil और एक एरर लौटाता है:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

MustCompile फंक्शन Compile का एक आसान विकल्प है:

re = regexp.MustCompile(`[a-z]+\d*`)

इस फंक्शन का इस्तेमाल करने पर एरर संभालने की ज़रूरत नहीं पड़ती।

रेगुलर एक्सप्रेशन के मेथड

Regexp में 16 मेथड हैं, जो रेगुलर एक्सप्रेशन से मैच ढूँढते हैं और मैच हुए टेक्स्ट की पहचान करते हैं। इन नामों का मेल इस रेगुलर एक्सप्रेशन से होता है:

Find(All)?(String)?(Submatch)?(Index)?

• अगर All मौजूद है, तो यह मेथड पूरे एक्सप्रेशन के एक के बाद एक, बिना ओवरलैप वाले मैच ढूँढता है।
• अगर String मौजूद है, तो आर्गुमेंट एक स्ट्रिंग होता है; वरना वह बाइट का स्लाइस होता है। रिटर्न वैल्यू उसी के मुताबिक ढल जाती हैं।
• अगर Submatch मौजूद है, तो रिटर्न वैल्यू एक स्लाइस होती है, जो एक्सप्रेशन के एक के बाद एक सबमैच बताती है।
• अगर Index मौजूद है, तो मैच और सबमैच इनपुट स्ट्रिंग के अंदर बाइट इंडेक्स के जोड़ों से पहचाने जाते हैं।

कुछ और काम करने वाले मेथड भी हैं:

• रेगुलर एक्सप्रेशन के मैच को रिप्लेसमेंट स्ट्रिंग से बदलना
• रेगुलर एक्सप्रेशन से अलग किए गए स्ट्रिंग को बाँटना

कुल मिलाकर regexp पैकेज 40 से अधिक फंक्शन और मेथड परिभाषित करता है। नीचे हम कुछ मेथड के इस्तेमाल का उदाहरण देखेंगे। इन और दूसरे फंक्शन की जानकारी के लिए API डॉक्यूमेंटेशन देखिए।

MatchString के उदाहरण

MatchString मेथड बताता है कि किसी स्ट्रिंग में रेगुलर एक्सप्रेशन का कोई मैच है या नहीं।

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

FindString के उदाहरण

FindString मेथड एक स्ट्रिंग लौटाता है जिसमें रेगुलर एक्सप्रेशन के सबसे बाएँ मैच का टेक्स्ट होता है।

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

FindStringSubmatch के उदाहरण

FindStringSubmatch मेथड स्ट्रिंग का एक स्लाइस लौटाता है, जिसमें रेगुलर एक्सप्रेशन के सबसे बाएँ मैच का टेक्स्ट और उसके सबएक्सप्रेशन के मैच (अगर हों) होते हैं। इसकी मदद से उन स्ट्रिंग की पहचान की जा सकती है जो कैप्चरिंग ग्रुप से मैच करती हैं। nil रिटर्न वैल्यू का मतलब है कि कोई मैच नहीं मिला।

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

ReplaceAllString के उदाहरण

re.ReplaceAllString(src,repl) मेथड src की एक कॉपी लौटाता है और उसमें रेगुलर एक्सप्रेशन re के मैच को रिप्लेसमेंट स्ट्रिंग repl से बदल देता है।

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Split के उदाहरण

re.Split(s,n) मेथड टेक्स्ट s को एक्सप्रेशन के मैचों के बीच की सबस्ट्रिंग में बाँटता है और उन सबस्ट्रिंग का स्लाइस लौटाता है। n संख्या तय करती है कि अधिकतम कितनी सबस्ट्रिंग लौटानी हैं। अगर n<0 है, तो यह मेथड सारी सबस्ट्रिंग लौटाता है।

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

प्रदर्शन

इस पैकेज में दिया गया regexp कार्यान्वयन इस बात की गारंटी देता है कि वह इनपुट के आकार के साथ रैखिक समय में चलता है।

चेतावनी

regexp पैकेज RE2 रेगुलर एक्सप्रेशन को कार्यान्वित करता है (\C को छोड़कर)। यह सिंटैक्स PCRE ("Perl कंपैटिबल रेगुलर एक्सप्रेशन") से काफी हद तक मेल खाता है, लेकिन कुछ अंतर भी हैं। जानकारी के लिए इस लेख का "Caveat section" देखिए।