लॉग फाइलें पार्स कीजिए

Go में रेगुलर एक्सप्रेशन के लिए 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"}