Java Language
नियमित अभिव्यक्ति

परिचय

वाक्य - विन्यास

• पैटर्न patternName = Pattern.compile (regex);
• मिलान मिलानकर्ता नाम = patternName.matcher (textToSearch);
• matcherName.matches () // सच सच है अगर textToSearch बिल्कुल regex से मेल खाता है
• matcherName.find () // पाठ के माध्यम से खोज करता है, जो रेगेक्स से मेल खाते सबस्ट्रिंग के पहले उदाहरण के लिए खोजता है। इसके बाद की कॉलिंग स्ट्रिंग के शेष भाग को खोजेगी।
• matcherName.group (groupNum) // एक कैप्चरिंग ग्रुप के अंदर सबस्ट्रिंग देता है
• matcherName.group (groupName) // एक नामित कैप्चरिंग ग्रुप (जावा 7+) के अंदर विकल्प को लौटाता है

टिप्पणियों

import java.util.regex.Matcher
import java.util.regex.Pattern

कैप्चर समूहों का उपयोग करना

यदि आपको इनपुट स्ट्रिंग से स्ट्रिंग का एक हिस्सा निकालने की आवश्यकता है, तो हम रेगेक्स के कैप्चर समूहों का उपयोग कर सकते हैं।

इस उदाहरण के लिए, हम एक साधारण फोन नंबर के साथ शुरू करेंगे:

\d{3}-\d{3}-\d{4}

यदि कोष्ठक को रेगेक्स में जोड़ा जाता है, तो कोष्ठक के प्रत्येक सेट को कैप्चरिंग समूह माना जाता है। इस मामले में, हम उपयोग कर रहे हैं जिन्हें गिने हुए कैप्चर समूह कहा जाता है:

(\d{3})-(\d{3})-(\d{4})
^-----^ ^-----^ ^-----^
Group 1 Group 2 Group 3

इससे पहले कि हम इसे जावा में उपयोग कर सकें, हमें स्ट्रिंग्स के नियमों का पालन नहीं करना चाहिए, बैकस्लैश से बचना चाहिए, जिसके परिणामस्वरूप निम्न पैटर्न होंगे:

"(\\d{3})-(\\d{3})-(\\d{4})"

हमें पहले पैटर्न बनाने के लिए रेगेक्स पैटर्न को संकलित करने की आवश्यकता है और फिर हमें Pattern के साथ हमारे इनपुट स्ट्रिंग से मिलान करने के लिए एक Matcher आवश्यकता है:

Pattern phonePattern = Pattern.compile("(\\d{3})-(\\d{3})-(\\d{4})");
Matcher phoneMatcher = phonePattern.matcher("abcd800-555-1234wxyz");

इसके बाद, मिलानकर्ता को पहले परिणाम को खोजने की जरूरत है जो रेगेक्स से मेल खाता है:

phoneMatcher.find();

अब, समूह विधि का उपयोग करके, हम स्ट्रिंग से डेटा निकाल सकते हैं:

String number = phoneMatcher.group(0); //"800-555-1234" (Group 0 is everything the regex matched)
String aCode = phoneMatcher.group(1); //"800"
String threeDigit = phoneMatcher.group(2); //"555"
String fourDigit = phoneMatcher.group(3); //"1234"

नोट: Matcher.group() का उपयोग Matcher.group(0) स्थान पर किया जा सकता है।

(?<AreaCode>\d{3})-(\d{3})-(\d{4})
^----------------^ ^-----^ ^-----^
AreaCode           Group 2 Group 3

String aCode = phoneMatcher.group("AreaCode"); //"800"

झंडे के साथ पैटर्न को संकलित करके कस्टम व्यवहार के साथ रेगेक्स का उपयोग करना

Pattern को झंडे के साथ संकलित किया जा सकता है, यदि रेगेक्स का उपयोग शाब्दिक String रूप में किया जाता है, इनलाइन संशोधक का उपयोग करें:

Pattern pattern = Pattern.compile("foo.", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
pattern.matcher("FOO\n").matches(); // Is true.

/* Had the regex not been compiled case insensitively and singlelined,
 * it would fail because FOO does not match /foo/ and \n (newline)
 * does not match /./.
 */

Pattern anotherPattern = Pattern.compile("(?si)foo");
anotherPattern.matcher("FOO\n").matches(); // Is true.

"foOt".replaceAll("(?si)foo", "ca"); // Returns "cat".

वर्ण से बचो

आम तौर पर

नियमित अभिव्यक्ति विशिष्ट वर्णों का उपयोग करने के लिए ( ?+| आदि) उनके शाब्दिक अर्थ में उन्हें बच निकलने की आवश्यकता है। सामान्य नियमित अभिव्यक्ति में यह बैकस्लैश \ _ द्वारा किया जाता है। हालाँकि, जैसा कि जावा स्ट्रिंग्स में इसका एक विशेष अर्थ है, आपको डबल बैकस्लैश \\ का उपयोग करना होगा।

ये दो उदाहरण काम नहीं करेंगे:

"???".replaceAll ("?", "!"); //java.util.regex.PatternSyntaxException
"???".replaceAll ("\?", "!"); //Invalid escape sequence

यह उदाहरण काम करता है

"???".replaceAll ("\\?", "!"); //"!!!"

एक पाइप सीमांकित स्ट्रिंग का विभाजन

यह अपेक्षित परिणाम नहीं देता है:

"a|b".split ("|"); // [a, |, b]

यह अपेक्षित परिणाम देता है:

"a|b".split ("\\|"); // [a, b]

बैकस्लैश से बचने \

यह एक त्रुटि देगा:

"\\".matches("\\"); // PatternSyntaxException
"\\".matches("\\\"); // Syntax Error

यह काम:

"\\".matches("\\\\"); // true

रेगेक्स शाब्दिक के साथ मिलान।

यदि आपको ऐसे वर्णों का मिलान करने की आवश्यकता है जो नियमित अभिव्यक्ति सिंटैक्स का एक हिस्सा हैं, तो आप रेगेक्स शाब्दिक के रूप में पैटर्न के सभी या भाग को चिह्नित कर सकते हैं।

\Q रेगेक्स शाब्दिक की शुरुआत को चिह्नित करता है। \E रेगेक्स शाब्दिक के अंत को चिह्नित करता है।

// the following throws a PatternSyntaxException because of the un-closed bracket
"[123".matches("[123");

// wrapping the bracket in \Q and \E allows the pattern to match as you would expect.
"[123".matches("\\Q[\\E123"); // returns true

ऐसा करने का एक आसान तरीका यह है कि बिना \Q और \E एस्केप दृश्यों को याद किए बिना Pattern.quote() का उपयोग किया Pattern.quote()

"[123".matches(Pattern.quote("[") + "123"); // returns true

दिए गए स्ट्रिंग से मेल नहीं खा रहा है

किसी ऐसी चीज से मेल खाने के लिए जिसमें कोई स्ट्रिंग नहीं दी गई है, कोई नकारात्मक लुकहेड का उपयोग कर सकता है:

रेगेक्स सिंटैक्स: (?!string-to-not-match)

उदाहरण:

//not matching "popcorn"
String regexString = "^(?!popcorn).*$";
System.out.println("[popcorn] " + ("popcorn".matches(regexString) ? "matched!" : "nope!"));
System.out.println("[unicorn] " + ("unicorn".matches(regexString) ? "matched!" : "nope!"));

आउटपुट:

[popcorn] nope!
[unicorn] matched!

एक बैकलैश मैचिंग

यदि आप अपनी नियमित अभिव्यक्ति में बैकस्लैश का मिलान करना चाहते हैं, तो आपको इससे बचना होगा।

बैकस्लैश नियमित अभिव्यक्तियों में एक एस्केप चरित्र है। आप एक नियमित अभिव्यक्ति में एक एकल बैकस्लैश को संदर्भित करने के लिए '\\' का उपयोग कर सकते हैं।

हालांकि, जावा शाब्दिक तार में बैकस्लैश भी एक भागने का पात्र है। एक स्ट्रिंग शाब्दिक से एक नियमित अभिव्यक्ति बनाने के लिए, आपको इसके प्रत्येक बैकस्लैश से बचना होगा। एक स्ट्रिंग में शाब्दिक '\\\\' का उपयोग '\\' के साथ एक नियमित अभिव्यक्ति बनाने के लिए किया जा सकता है, जो बदले में '\' से मेल खा सकता है।

उदाहरण के लिए, "C: \ dir \ myfile.txt" जैसे स्ट्रिंग का मिलान करें। एक नियमित अभिव्यक्ति ([A-Za-z]):\\(.*) मिलान करेगा और ड्राइव अक्षर को एक कैप्चरिंग ग्रुप के रूप में प्रदान करेगा। डबल बैकस्लैश नोट करें।

एक जावा स्ट्रिंग शाब्दिक में उस पैटर्न को व्यक्त करने के लिए, नियमित अभिव्यक्ति में बैकस्लैश के प्रत्येक को बचाना होगा।

    String path = "C:\\dir\\myfile.txt";
    System.out.println( "Local path: " + path ); // "C:\dir\myfile.txt"
    
    String regex = "([A-Za-z]):\\\\.*"; // Four to match one
    System.out.println("Regex:      " + regex ); // "([A-Za-z]):\\(.*)"
    
    Pattern pattern = Pattern.compile( regex );
    Matcher matcher = pattern.matcher( path );
    if ( matcher.matches()) {
        System.out.println( "This path is on drive " + matcher.group( 1 ) + ":.");
        // This path is on drive C:.
    }

यदि आप दो बैकस्लैशों का मिलान करना चाहते हैं, तो आप स्वयं को शाब्दिक स्ट्रिंग में आठ का उपयोग करते हुए पाएंगे, नियमित अभिव्यक्ति में चार का प्रतिनिधित्व करने के लिए, दो का मिलान करने के लिए।

    String path = "\\\\myhost\\share\\myfile.txt";
    System.out.println( "UNC path: " + path ); // \\myhost\share\myfile.txt"
    
    String regex = "\\\\\\\\(.+?)\\\\(.*)"; // Eight to match two
    System.out.println("Regex:    " + regex ); // \\\\(.+?)\\(.*) 
    
    Pattern pattern = Pattern.compile( regex );
    Matcher matcher = pattern.matcher( path );
    
    if ( matcher.matches()) {
        System.out.println( "This path is on host '" + matcher.group( 1 ) + "'.");
        // This path is on host 'myhost'.
    }