Rust में रेगुलर एक्सप्रेशन: शुरुआती लोगों के लिए पूर्ण गाइड

Rust में रेगुलर एक्सप्रेशन का परिचय

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

Rust में रेगुलर एक्सप्रेशन क्यों सीखें? यह भाषा टेक्स्ट के साथ सुरक्षित और तेज़ काम प्रदान करती है, और क्रेट regex मेमोरी लीक की अनुपस्थिति और उच्च निष्पादन गति की गारंटी देता है। यह Rust को लॉग पार्सिंग, फॉर्म सत्यापन, कॉन्फ़िगरेशन फ़ाइल प्रोसेसिंग और अन्य कार्यों के लिए एक उत्कृष्ट विकल्प बनाता है।

regex क्रेट की स्थापना और उपयोग

आरंभ करने के लिए, अपनी Cargo.toml फ़ाइल में regex निर्भरता जोड़ें:

[dependencies]\nregex = "1.10"

उसके बाद, कोड में मॉड्यूल आयात करें:

use regex::Regex;

आप जिस मुख्य संरचना के साथ काम करेंगे वह Regex है। Regex::new() विधि का उपयोग करके एक इंस्टेंस बनाया जा सकता है, जो Result लौटाता है, क्योंकि पैटर्न अमान्य हो सकता है।

fn main() {\n    let re = Regex::new(r"^\\d{3}-\\d{2}-\\d{4}$").unwrap();\n    println!("Regex बनाया गया: {}", re.as_str());\n}

ध्यान दें: पैटर्न को रॉ स्ट्रिंग (r"...") में लिखा जाता है ताकि बैकस्लैश को एस्केप करने से बचा जा सके।

रेगुलर एक्सप्रेशन के साथ मुख्य संचालन

1. मिलान की जाँच: is_match

is_match विधि true लौटाती है यदि स्ट्रिंग में पैटर्न पाया जाता है:

use regex::Regex;\n\nfn main() {\n    let re = Regex::new(r"hello").unwrap();\n    let text = "hello world";\n    \n    if re.is_match(text) {\n        println!("मिलान मिल गया!");\n    } else {\n        println!("कोई मिलान नहीं");\n    }\n}

आउटपुट: मिलान मिल गया!

2. पहला मिलान खोजें: find

find विधि Option<Match> लौटाती है - स्थिति की जानकारी के साथ पहला मिलान:

use regex::Regex;\n\nfn main() {\n    let re = Regex::new(r"\\d+").unwrap();\n    let text = "कोड: 12345, मूल्य: 678";\n    \n    if let Some(m) = re.find(text) {\n        println!("पाया गया: '{}' (स्थिति {}..{})", m.as_str(), m.start(), m.end());\n    }\n}

आउटपुट: पाया गया: '12345' (स्थिति 5..10)

3. सभी मिलान खोजें: find_iter

सभी मिलान प्राप्त करने के लिए इटरेटर find_iter का उपयोग करें:

use regex::Regex;\n\nfn main() {\n    let re = Regex::new(r"\\d+").unwrap();\n    let text = "संख्याएँ: 42, 100, 7";\n    \n    for m in re.find_iter(text) {\n        println!("संख्या: {}", m.as_str());\n    }\n}

आउटपुट:

संख्या: 42\nसंख्या: 100\nसंख्या: 7

4. समूह निकालना: captures

पैटर्न में समूह (गोल कोष्ठक द्वारा दर्शाए गए) मिलान के भागों को निकालने की अनुमति देते हैं:

use regex::Regex;\n\nfn main() {\n    let re = Regex::new(r"(\\w+)@(\\w+)\\.(\\w+)").unwrap();\n    let email = "user@example.com";\n    \n    if let Some(caps) = re.captures(email) {\n        println!("पूरा ईमेल: {}", &caps[0]);\n        println!("नाम: {}", &caps[1]);\n        println!("डोमेन: {}", &caps[2]);\n        println!("ज़ोन: {}", &caps[3]);\n    }\n}

आउटपुट:

पूरा ईमेल: user@example.com\nनाम: user\nडोमेन: example\nज़ोन: com

उपयोग के व्यावहारिक उदाहरण

उदाहरण 1: फ़ोन नंबर का सत्यापन

जाँच करें कि क्या स्ट्रिंग रूसी नंबर के प्रारूप से मेल खाती है (उदाहरण के लिए, +7-XXX-XXX-XX-XX):

use regex::Regex;\n\nfn v