Go में नियमित अभिव्यक्तियाँ उदाहरणों के साथ: पूर्ण गाइड

Go में नियमित अभिव्यक्तियाँ उदाहरणों के साथ

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

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

regexp पैकेज दो मुख्य दृष्टिकोण प्रदान करता है: त्वरित एकल उपयोग (पैकेज स्तर के फ़ंक्शन) और पूर्व-संकलित पैटर्न के साथ कुशल कार्य (Regexp संरचना)। बार-बार उपयोग के लिए, हमेशा पैटर्न को पहले से संकलित करें।

नियमित अभिव्यक्ति का संकलन

package main

import (    "fmt"    "regexp")

func main() {    // पैटर्न का संकलन (त्रुटि प्रबंधन के साथ अनुशंसित तरीका)    pattern, err := regexp.Compile(`\\d+`)    if err != nil {        fmt.Println("संकलन त्रुटि:", err)        return    }        // सरल मामलों के लिए — त्रुटि प्रबंधन के बिना (अमान्य पैटर्न पर पैनिक)    patternMust := regexp.MustCompile(`[a-z]+`)        fmt.Println(pattern, patternMust)}

Compile यदि पैटर्न अमान्य है तो त्रुटि लौटाता है। MustCompile पैनिक का कारण बनता है — इसका उपयोग केवल स्थिर पैटर्न के लिए करें।

2. मूल संचालन: खोज और जाँच

मिलान जाँच और सबस्ट्रिंग खोज के लिए मुख्य विधियों पर विचार करें।

आंशिक मिलान की जाँच

pattern := regexp.MustCompile(`go`)text := "मैं Golang सीख रहा हूँ"

// MatchString — क्या स्ट्रिंग में पैटर्न से मेल खाने वाली सबस्ट्रिंग हैmatched := pattern.MatchString(text)fmt.Println(matched) // true (क्योंकि "Golang" में "go" मौजूद है)

पूर्ण मिलान की जाँच

// यह जाँचने के लिए कि पूरी स्ट्रिंग पैटर्न से मेल खाती है, एंकर ^ और $ का उपयोग करेंfullPattern := regexp.MustCompile(`^[a-zA-Z]+$`)fmt.Println(fullPattern.MatchString("Hello"))   // truefmt.Println(fullPattern.MatchString("Hello1"))  // false

पहला मिलान खोजें

datePattern := regexp.MustCompile(`\\d{2}\\.\\d{2}\\.\\d{4}`)text := "आज 15.03.2024 है, और कल 16.03.2024 है"

// FindString — पहला मिलान लौटाता हैfirstDate := datePattern.FindString(text)fmt.Println(firstDate) // "15.03.2024"

सभी मिलान खोजें

// FindAllString — सभी मिलानों का स्लाइस लौटाता हैallDates := datePattern.FindAllString(text, -1) // -1 — सभी मिलानfmt.Println(allDates) // ["15.03.2024" "16.03.2024"]

// मात्रा सीमित करें: FindAllString(text, 1) — केवल पहला

3. कैप्चर समूह और प्रतिस्थापन

कैप्चर समूह मिलान के भागों को निकालने की अनुमति देते हैं। Go में, समूहों को गोल कोष्ठक () से दर्शाया जाता है।

समूहों द्वारा डेटा निकालना

// नाम और आयु निकालने के लिए पैटर्न: "नाम: [नाम], आयु: [संख्या]"personPattern := regexp.MustCompile(`नाम: (\\w+), आयु: (\\d+)`)text := "नाम: अलेक्से, आयु: 30"

// FindStringSubmatch — स्लाइस लौटाता है: [पूरा_मिलान, समूह1, समूह2, ...]matches := personPattern.FindStringSubmatch(text)if len(matches) > 0 {    fmt.Println("पूरा मिलान:", matches[0]) // "नाम: अलेक्से, आयु: 30"    fmt.Println("नाम:", matches[1])                // "अलेक्से"    fmt.Println("आयु:", matches[2])            // "30"}

नामित समूह (Go 1.21+)

// Go 1.21 से, नामित समूहों का उपयोग किया जा सकता है: (?P<नाम>पैटर्न)pattern := regexp.MustCompile(`(?P<name>\\w+)@(?P<domain>\\w+\\.\\w+)`)text := "test@example.com"

// SubexpNames — समूहों के नाम प्राप्त करेंgroupNames := pattern.SubexpNames()matches := pattern.FindStringSubmatch(text)

// मैप बनाएं: समूह_नाम