हम इस ट्यूटोरियल में सीखने वाले है कि जावा रेगुलर एक्सप्रेशंस (Java Regular Expressions in Hindi) और हम इसे कैसे इस्तमाल कर सकते हैं? जावा रेगुलर एक्सप्रेशंस के साथ पैटर्न मिलान के लिए java.util.regex पैकेज प्रदान करता है। जावा नियमित Expression पर्ल प्रोग्रामिंग (Perl programming) भाषा के समान हैं और सीखने में बहुत आसान हैं।
एक रेगुलर एक्सप्रेशन वर्णों का एक विशेष अनुक्रम है जो पैटर्न में रखे गए एक विशेष सिंटैक्स का उपयोग करके आपको अन्य स्ट्रिंग्स या स्ट्रिंग्स के सेट से मेल खाने या खोजने में मदद करता है। उनका उपयोग पाठ और डेटा को खोजने, edited करने या हेरफेर करने के लिए किया जा सकता है।
Table of Contents
Java.util.regex पैकेज में मुख्य रूप से निम्नलिखित तीन वर्ग होते हैं –
पैटर्न क्लास (Pattern Class) – एक पैटर्न ऑब्जेक्ट रेगुलर एक्सप्रेशन का compiled Representation है। पैटर्न वर्ग कोई सार्वजनिक निर्माता प्रदान नहीं करता है। एक पैटर्न बनाने के लिए, आपको पहले इसके सार्वजनिक स्थैतिक संकलन () विधियों में से एक को लागू करना होगा, जो तब एक पैटर्न ऑब्जेक्ट लौटाएगा। ये विधियां नियमित Expression को पहले तर्क के रूप में स्वीकार करती हैं।
मैचर क्लास (Matcher Class) – एक मैचर ऑब्जेक्ट वह इंजन है जो पैटर्न की व्याख्या करता है और इनपुट स्ट्रिंग के विरुद्ध मैच संचालन करता है। पैटर्न वर्ग की तरह, मैचर सार्वजनिक निर्माणकर्ताओं को परिभाषित नहीं करता है। आप पैटर्न ऑब्जेक्ट पर मैचर () विधि को कॉल करके एक मैचर ऑब्जेक्ट प्राप्त कर सकते हैं।
PatternSyntaxException – एक PatternSyntaxException ऑब्जेक्ट एक अनियंत्रित अपवाद है जो नियमित Expression पैटर्न में सिंटैक्स Error को इंगित करता है।
कैप्चरिंग ग्रुप्स (Capturing Groups)
कैप्चरिंग समूह एक इकाई के रूप में एकाधिक वर्णों का इलाज करने का एक तरीका है। वे वर्णों को parentheses के एक समूह के भीतर grouped करके बनाए जाते हैं। उदाहरण के लिए, रेगुलर एक्सप्रेशन (dog) अक्षर “d”, “o”, और “g” वाले एकल समूह बनाता है।
कैप्चरिंग समूहों को उनके शुरुआती parentheses को बाईं से दाईं ओर गिनकर क्रमांकित किया जाता है। Expression ((A) (B (C))) में, उदाहरण के लिए, ऐसे चार समूह हैं –
((A)(B(C)))
(A)
(B(C))
(C)
यह पता लगाने के लिए कि Expression में कितने समूह मौजूद हैं, मैचर ऑब्जेक्ट पर GroupCount विधि को कॉल करें। GroupCount विधि मैचर के पैटर्न में मौजूद कैप्चरिंग समूहों की संख्या दिखाते हुए एक इंट लौटाती है।
एक विशेष समूह भी है, समूह 0, जो हमेशा संपूर्ण Expression का Representation करता है। GroupCount द्वारा रिपोर्ट किए गए कुल में यह समूह शामिल नहीं है।
उदाहरण
निम्नलिखित उदाहरण दिखाता है कि दिए गए अल्फ़ान्यूमेरिक स्ट्रिंग से एक अंक स्ट्रिंग कैसे प्राप्त करें
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
public static void main( String args[] ) {
// पैटर्न खोजने के लिए स्कैन की जाने वाली स्ट्रिंग।
String line = “This order was placed for QT3000! OK?”;
String pattern = “(.*)(\\d+)(.*)”;
// एक पैटर्न वस्तु बनाएँ
Pattern r = Pattern.compile(pattern);
// अब मैचर ऑब्जेक्ट बनाएं।
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println(“Found value: ” + m.group(0) );
System.out.println(“Found value: ” + m.group(1) );
System.out.println(“Found value: ” + m.group(2) );
}else {
System.out.println(“NO MATCH”);
}
}
}
यह निम्नलिखित परिणाम देगा –
Output
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0
रेगुलर एक्सप्रेशन सिंटैक्स (Regular Expression Syntax in Hindi)
यहाँ जावा में उपलब्ध सभी रेगुलर एक्सप्रेशन मेटाचैकर सिंटैक्स की सूची दी गई है –
| Subexpression | Matches |
| ^ | लाइन की शुरुआत से मेल खाता है। |
| $ | पंक्ति के अंत से मेल खाता है। |
| . | न्यूलाइन को छोड़कर किसी एक वर्ण से मेल खाता है। एम विकल्प का उपयोग करने से यह न्यूलाइन से भी मेल खा सकता है। |
| […] | कोष्ठक में किसी एक वर्ण से मेल खाता है। |
| [^…] | कोष्ठक में नहीं किसी एक वर्ण से मेल खाता है। |
| \A | entire string की शुरुआत। |
| \z | पूरी कड़ी का अंत। |
| \Z | acceptable अंतिम लाइन टर्मिनेटर को छोड़कर संपूर्ण स्ट्रिंग का अंत। |
| re* | पिछली अभिव्यक्ति की 0 या अधिक घटनाओं से मेल खाता है। |
| re+ | पिछली चीज़ के 1 या अधिक से मेल खाता है। |
| re? | पिछली अभिव्यक्ति की 0 या 1 घटना से मेल खाता है। |
| re{ n} | Previous अभिव्यक्ति की घटनाओं की ठीक n संख्या से मेल खाता है। |
| re{ n,} | Previous अभिव्यक्ति की n या अधिक घटनाओं से मेल खाता है। |
| re{ n, m} | Previous अभिव्यक्ति की कम से कम n और अधिकतम m घटनाओं से मेल खाता है। |
| a| b | ए या बी से मेल खाता है। |
| (re) | समूह नियमित अभिव्यक्तियाँ और मिलान किए गए पाठ को याद रखता है। |
| (?: re) | मिलान किए गए पाठ को याद किए बिना समूह नियमित अभिव्यक्तियाँ। |
| (?> re) | बैकट्रैकिंग के बिना स्वतंत्र पैटर्न से मेल खाता है। |
| \w | शब्द वर्णों से मेल खाता है। |
| \W | गैर-शब्द वर्णों से मेल खाता है। |
| \s | खाली स्थान से मेल खाता है। [\t\n\r\f] के बराबर। |
| \S | गैर सफेद स्थान का मिलान करें। |
| \d | अंकों से मेल खाता है। [0-9] के बराबर। |
| \D | नॉनडिजिट से मेल खाता है। |
| \A | स्ट्रिंग की शुरुआत से मेल खाता है। |
| \Z | स्ट्रिंग के अंत से मेल खाता है। यदि कोई नई रेखा मौजूद है, तो यह नई रेखा से ठीक पहले मेल खाती है। |
| \z | स्ट्रिंग के अंत से मेल खाता है। |
| \G | उस बिंदु से मेल खाता है जहां पिछला मैच समाप्त हुआ था। |
| \n | समूह संख्या “एन” पर कब्जा करने के लिए बैक-रेफरेंस। |
| \b | कोष्ठक के बाहर होने पर शब्द सीमाओं से मेल खाता है। ब्रैकेट के अंदर बैकस्पेस (0x08) से मेल खाता है। |
| \B | गैर-शब्द सीमाओं से मेल खाता है। |
| \n, \t, etc. | न्यूलाइन, कैरिज रिटर्न, टैब आदि से मेल खाता है। |
| \Q | \E तक के सभी वर्ण एस्केप (उद्धरण) करें। |
| \E | \Q से कोटेशन शुरू होता है। |
मैचर क्लास के तरीके (Methods of the Matcher Class in Hindi)
यहाँ उपयोगी उदाहरण विधियों की एक सूची है –
सूचकांक के तरीके (Index Methods)
अनुक्रमणिका विधियां उपयोगी अनुक्रमणिका मान प्रदान करती हैं जो दर्शाती हैं कि इनपुट स्ट्रिंग – में मिलान कहां पाया गया था
| Sr.No. | Method & Description |
| 1 | public int start() पिछले मैच का स्टार्ट इंडेक्स लौटाता है। |
| 2 | public int start(int group) पिछले मैच ऑपरेशन के दौरान दिए गए समूह द्वारा कैप्चर किए गए अनुवर्ती का प्रारंभ सूचकांक लौटाता है। |
| 3 | public int end() अंतिम वर्ण मिलान के बाद ऑफ़सेट लौटाता है। |
| 4 | public int end(int group) पिछले मैच ऑपरेशन के दौरान दिए गए समूह द्वारा कैप्चर किए गए बाद के अंतिम वर्ण के बाद ऑफ़सेट लौटाता है। |
अध्ययन के तरीके (Study Methods in Hindi)
अध्ययन के तरीके इनपुट स्ट्रिंग की समीक्षा करते हैं और एक बूलियन लौटाते हैं जो दर्शाता है कि पैटर्न मिला है या नहीं –
| Sr.No. | Method & Description |
| 1 | public boolean lookingAt() पैटर्न के खिलाफ, क्षेत्र की शुरुआत से शुरू होने वाले इनपुट अनुक्रम से मिलान करने का प्रयास। |
| 2 | public boolean find() पैटर्न से मेल खाने वाले इनपुट अनुक्रम के अगले क्रम को खोजने का प्रयास करता है। |
| 3 | public boolean find(int start) इस मैचर को रीसेट करता है और फिर Specified इंडेक्स से शुरू होने वाले पैटर्न से मेल खाने वाले इनपुट अनुक्रम के अगले अनुक्रम को खोजने का प्रयास करता है। |
| 4 | public boolean matches() पैटर्न के खिलाफ पूरे क्षेत्र का मिलान करने का प्रयास करता है। |
प्रतिस्थापन के तरीके (Replacement Methods in Hindi)
इनपुट स्ट्रिंग में टेक्स्ट को बदलने के लिए प्रतिस्थापन विधियाँ उपयोगी विधियाँ हैं –
| Sr.No. | Method & Description |
| 1 | public Matcher appendReplacement(StringBuffer sb, String replacement) एक गैर-टर्मिनल एपेंड-एंड-रिप्लेस चरण लागू करता है। |
| 2 | public StringBuffer appendTail(StringBuffer sb) एक टर्मिनल एपेंड-एंड-रिप्लेस स्टेप को लागू करता है। |
| 3 | public String replaceAll(String replacement) दिए गए प्रतिस्थापन स्ट्रिंग के साथ पैटर्न से मेल खाने वाले इनपुट अनुक्रम के प्रत्येक अनुक्रम को प्रतिस्थापित करता है। |
| 4 | public String replaceFirst(String replacement) दिए गए प्रतिस्थापन स्ट्रिंग के साथ पैटर्न से मेल खाने वाले इनपुट अनुक्रम के पहले अनुक्रम को प्रतिस्थापित करता है। |
| 5 | public static String quoteReplacement(String s) Specified स्ट्रिंग के लिए शाब्दिक प्रतिस्थापन स्ट्रिंग लौटाता है। यह विधि एक स्ट्रिंग का उत्पादन करती है जो मैचर वर्ग के परिशिष्ट प्रतिस्थापन विधि में शाब्दिक प्रतिस्थापन के रूप में काम करेगी। |
प्रारंभ और अंत के तरीके (The start and end Methods)
निम्नलिखित उदाहरण है जो इनपुट स्ट्रिंग – में “बिल्ली” शब्द के प्रकट होने की संख्या की गणना करता है
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = “\\bcat\\b”;
private static final String INPUT = “cat cat cat cattie cat”;
public static void main( String args[] ) {
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // एक मिलान वस्तु प्राप्त करें
int count = 0;
while(m.find()) {
count++;
System.out.println(“Match number “+count);
System.out.println(“start(): “+m.start());
System.out.println(“end(): “+m.end());
}
}
}
यह निम्नलिखित परिणाम देगा –
Output
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
आप देख सकते हैं कि यह उदाहरण यह सुनिश्चित करने के लिए शब्द सीमाओं का उपयोग करता है कि अक्षर “सी” “ए” “टी” केवल एक लंबे शब्द में एक सबस्ट्रिंग नहीं हैं। यह कुछ उपयोगी जानकारी भी देता है कि इनपुट स्ट्रिंग में मैच कहाँ हुआ है।
स्टार्ट मेथड पिछले मैच ऑपरेशन के दौरान दिए गए समूह द्वारा कैप्चर किए गए बाद के स्टार्ट इंडेक्स को लौटाता है, और अंत में मिलान किए गए अंतिम वर्ण का इंडेक्स, प्लस वन देता है।
मैच और लुकिंग मेथड्स (The matches and lookingAt Methods)
मैच और लुकिंग विधियाँ दोनों एक पैटर्न के विरुद्ध एक इनपुट अनुक्रम का मिलान करने का प्रयास करती हैं। हालाँकि, अंतर यह है कि मैच के लिए पूरे इनपुट अनुक्रम का मिलान करना आवश्यक है, जबकि लुकएट के लिए ऐसा नहीं है।
दोनों विधियां हमेशा इनपुट स्ट्रिंग की शुरुआत में शुरू होती हैं। यहाँ कार्यक्षमता की व्याख्या करने वाला उदाहरण दिया गया है –
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = “foo”;
private static final String INPUT = “fooooooooooooooooo”;
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ) {
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println(“Current REGEX is: “+REGEX);
System.out.println(“Current INPUT is: “+INPUT);
System.out.println(“lookingAt(): “+matcher.lookingAt());
System.out.println(“matches(): “+matcher.matches());
}
}
यह निम्नलिखित परिणाम देगा –
Output
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false
रिप्लेस फर्स्ट और रिप्लेस ऑल मेथड्स (The replaceFirst and replaceAll Methods)
रिप्लेस फर्स्ट और रिप्लेस ऑल मेथड्स उस टेक्स्ट को रिप्लेस करते हैं जो किसी दिए गए रेगुलर एक्सप्रेशन से मेल खाता है। जैसा कि उनके नाम इंगित करते हैं, रिप्लेसफर्स्ट पहली घटना को प्रतिस्थापित करता है और सभी घटनाओं को प्रतिस्थापित करता है।
यहाँ कार्यक्षमता की व्याख्या करने वाला उदाहरण दिया गया है –
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = “dog”;
private static String INPUT = “The dog says meow. ” + “All dogs say meow.”;
private static String REPLACE = “cat”;
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// एक मिलान वस्तु प्राप्त करें
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
यह निम्नलिखित परिणाम देगा –
Output
The cat says meow. All cats say meow.
परिशिष्ट प्रतिस्थापन और परिशिष्ट विधियाँ (The appendReplacement and appendTail Methods)
मैचर क्लास टेक्स्ट रिप्लेसमेंट के लिए एपेंडरीप्लेसमेंट और एपेंडटेल मेथड भी प्रदान करता है।
यहाँ कार्यक्षमता की व्याख्या करने वाला उदाहरण दिया गया है –
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = “a*b”;
private static String INPUT = “aabfooaabfooabfoob”;
private static String REPLACE = “-“;
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()) {
m.appendReplacement(sb, REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
यह निम्नलिखित परिणाम देगा –
Output
-foo-foo-foo-
पैटर्न सिंटैक्स अपवाद वर्ग के तरीके (PatternSyntaxException Class Methods)
एक PatternSyntaxException एक अनियंत्रित अपवाद है जो नियमित Expression पैटर्न में सिंटैक्स Error को इंगित करता है। PatternSyntaxException क्लास आपको यह निर्धारित करने में मदद करने के लिए निम्न विधियाँ प्रदान करती है कि क्या गलत हुआ –
| Sr.No. | Method & Description |
| 1 | public String getDescription() Error का विवरण पुनर्प्राप्त करता है। |
| 2 | public int getIndex() Error सूचकांक को पुनः प्राप्त करता है। |
| 3 | public String getPattern() गलत रेगुलर एक्सप्रेशन पैटर्न को पुनः प्राप्त करता है। |
| 4 | public String getMessage() एक बहु-पंक्ति स्ट्रिंग लौटाता है जिसमें सिंटैक्स Error और उसके सूचकांक का विवरण, गलत नियमित Expression पैटर्न और पैटर्न के भीतर Error सूचकांक का एक दृश्य संकेत होता है। |
हम उम्मीद करते है कि आपको “जावा रेगुलर एक्सप्रेशंस (Java Regular Expressions)” से सम्बंधित जानकारी हिंदी में समझ में आयी होंगी यदि आपको बताई गई जानकारी अच्छी लगी हो तो अपने दोस्तों में ऐसे शेयर करे जिससे उनकी भी हेल्प हो सके धन्यवाद!