Go में रेगुलर एक्सप्रेशन उदाहरण सहित: पूर्ण गाइड

Go में रेगुलर एक्सप्रेशन: टेक्स्ट के साथ काम करने के लिए शक्तिशाली उपकरण

रेगुलर एक्सप्रेशन (regex) पैटर्न के आधार पर टेक्स्ट को खोजने, निकालने और बदलने के लिए एक अपरिहार्य उपकरण है। Go (Golang) भाषा में, रेगुलर एक्सप्रेशन के साथ काम करना मानक पैकेज regexp के माध्यम से कार्यान्वित किया जाता है। यह Perl और RE2 के समान सिंटैक्स का उपयोग करके पैटर्न के साथ काम करने का एक तेज़ और सुरक्षित तरीका प्रदान करता है। इस लेख में, हम व्यावहारिक उदाहरणों के साथ पैकेज के मुख्य कार्यों का विश्लेषण करेंगे।

1. regexp पैकेज के साथ काम करने की मूल बातें

पैकेज regexp "एक बार कंपाइल करें, कई बार उपयोग करें" के सिद्धांत का पालन करता है। यह एक ही पैटर्न के बार-बार उपयोग पर प्रदर्शन को बढ़ाता है। मुख्य कार्य:

• regexp.Compile(expr) — रेगुलर एक्सप्रेशन को कंपाइल करता है। *Regexp और एक त्रुटि लौटाता है।
• regexp.MustCompile(expr) — वही काम करता है, लेकिन त्रुटि होने पर पैनिक कॉल करता है। ग्लोबल वेरिएबल्स को इनिशियलाइज़ करने के लिए सुविधाजनक।
• regexp.MatchString(expr, s) — जाँचता है कि स्ट्रिंग s में पैटर्न से कम से कम एक मिलान है या नहीं।

package main

import (    "fmt"    "regexp")

func main() {    // सरल जाँच: क्या स्ट्रिंग में अंक हैं?    matched, _ := regexp.MatchString(`\\d+`, "ऑर्डर №12345")    fmt.Println(matched) // true

    // बार-बार उपयोग के लिए पैटर्न कंपाइल करें    re := regexp.MustCompile(`[a-z]+`)    fmt.Println(re.MatchString("hello")) // true    fmt.Println(re.MatchString("HELLO")) // false}

ध्यान दें: डिफ़ॉल्ट रूप से, MatchString आंशिक मिलान खोजता है (जैसे strings.Contains)। स्ट्रिंग के पैटर्न से पूर्ण मिलान के लिए, एंकर ^ और $ का उपयोग करें।

2. डेटा खोजना और निकालना

सभी मिलान या पहली घटना खोजने के लिए, FindString, FindAllString, FindStringSubmatch और बाइट स्लाइस के लिए उनके समकक्ष विधियों का उपयोग करें।

2.1. पहला मिलान खोजना

re := regexp.MustCompile(`\\b\\w+@\\w+\\.\\w+\\b`)email := re.FindString("हमसे संपर्क करें: support@example.com या info@test.org")fmt.Println(email) // support@example.com

2.2. सभी मिलान खोजना

re := regexp.MustCompile(`\\d{4}`)numbers := re.FindAllString("कोड: 1234, 5678, 9012", -1)fmt.Println(numbers) // [1234 5678 9012]

FindAllString का दूसरा आर्गुमेंट — मिलानों की अधिकतम संख्या है। -1 का अर्थ है "सभी"।

2.3. कैप्चर ग्रुप (submatch)

कैप्चर ग्रुप आपको मिलान के कुछ हिस्सों को निकालने की अनुमति देते हैं। वे गोल कोष्ठक () द्वारा निर्दिष्ट किए जाते हैं।

re := regexp.MustCompile(`(\\w+)@(\\w+\\.\\w+)`)match := re.FindStringSubmatch("user@example.com")fmt.Println(match) // [user@example.com user example.com]// match[0] — पूरा मिलान// match[1] — पहला ग्रुप (user)// match[2] — दूसरा ग्रुप (example.com)

3. रेगुलर एक्सप्रेशन का उपयोग करके टेक्स्ट बदलना

पैकेज regexp प्रतिस्थापन के लिए दो मुख्य विधियाँ प्रदान करता है:

• ReplaceAllString(src, repl) — सभी मिलानों को स्ट्रिंग repl से बदलता है।
• ReplaceAllStringFunc(src, replFunc) — कॉलबैक फ़ंक्शन का उपयोग करके प्रत्येक मिलान को बदलता है।

3.1. सरल प्रतिस्थापन

re := regexp.MustCompile(`\\s+`)result := re.ReplaceAllString("यहाँ   बहुत   सारे   स्पेस   हैं", " ")fmt.Println(result) // "यहाँ बहुत सारे स्पेस हैं"

3.2. कैप्चर ग्रुप का उपयोग करके प्रतिस्थापन

प्रतिस्थापन स्ट्रिंग में, आप $1, $2 आदि के माध्यम से ग्रुप को संदर्भित कर सकते हैं।

re := regexp.MustCompile(`(\\w+)\\s+(\\w+)`)result := re.ReplaceAllString("राम शर्मा", "$2, $1")