Backreferences এবং Lookaround Assertions

Regular Expressions (Regex) একটি অত্যন্ত শক্তিশালী টুল যা টেক্সট ম্যানিপুলেশন, অনুসন্ধান, এবং ভ্যালিডেশন করার জন্য ব্যবহৃত হয়। Java তে backreferences এবং lookaround assertions এর মতো উন্নত Regex ফিচারগুলি রয়েছে, যা আরও জটিল টেক্সট প্যাটার্ন এবং ম্যাচিং শর্তগুলি ব্যবহার করতে সহায়ক।

এগুলো বিশেষত advanced pattern matching এবং text parsing এর জন্য ব্যবহৃত হয়। চলুন দেখি Backreferences এবং Lookaround Assertions সম্পর্কে বিস্তারিত।

1. Backreferences

Backreference হচ্ছে এমন একটি ফিচার যেখানে আপনি একটি প্যাটার্নের মধ্যে আগে পাওয়া অংশকে আবার রেফারেন্স করতে পারেন। এটি টেক্সটের একটি নির্দিষ্ট অংশের সাথে মিল খুঁজে পেতে ব্যবহার করা হয়।

ব্যাখ্যা:

• Backreference একটি capturing group (প্যারেন্টেসিস () এর মাধ্যমে তৈরি করা) দ্বারা সংরক্ষিত মানকে পুনরায় ব্যবহার করতে পারে।
• Backreference Syntax: \n যেখানে n হলো সেই capturing group এর নম্বর।

উদাহরণ:

ধরা যাক, আমরা এমন একটি স্ট্রিং খুঁজছি যেখানে একটি শব্দ বা সংখ্যা দুটি বার টানানো হচ্ছে, যেমন abc abc বা 123 123।

import java.util.regex.*;

public class BackreferenceExample {
    public static void main(String[] args) {
        // Regex pattern with backreference
        String pattern = "(\\w+) \\1"; // Capturing group and backreference

        // String to search
        String text = "abc abc";

        // Compile the pattern
        Pattern p = Pattern.compile(pattern);

        // Create a matcher
        Matcher m = p.matcher(text);

        // Check if the pattern matches
        if (m.matches()) {
            System.out.println("Pattern matched!");
        } else {
            System.out.println("Pattern not matched.");
        }
    }
}

আউটপুট:

Pattern matched!

ব্যাখ্যা:

• (\\w+) একটি capturing group তৈরি করেছে যা এক বা একাধিক শব্দ ক্যারেক্টার গ্রহণ করবে (যেমন "abc")।
• \\1 একটি backreference যা capturing group 1 এর মানকে পুনরায় ব্যবহার করে, অর্থাৎ স্ট্রিং এর পরবর্তী অংশে ঠিক একই শব্দ থাকতে হবে।
• টেক্সট "abc abc" এটি মেলাবে কারণ প্রথম "abc" এবং দ্বিতীয় "abc" একই।

আরেকটি উদাহরণ:

• Pattern: (\\d+)\\s+\\1
• এটি এমন স্ট্রিং খুঁজে বের করবে যেখানে প্রথমে একটি সংখ্যা (যেমন 123) আসবে এবং পরবর্তী অংশে একই সংখ্যা (অর্থাৎ 123) আবার আসবে।

2. Lookaround Assertions

Lookaround Assertions হল একটি বিশেষ ধরনের zero-width assertions, যা একটি প্যাটার্নের পূর্ববর্তী বা পরবর্তী অংশের সাথে সম্পর্কিত শর্তগুলি পরীক্ষা করে কিন্তু সেই অংশটিকে ম্যাচ হিসেবে অন্তর্ভুক্ত করে না। এটি মূলত positive lookahead, negative lookahead, positive lookbehind, এবং negative lookbehind এর মধ্যে বিভক্ত।

Types of Lookaround Assertions:

1. Positive Lookahead (?=...):
   • এটি চেক করে যে পরবর্তী অংশের মধ্যে প্যাটার্নটি মিলে কিনা।
   • Syntax: X(?=Y) - যেখানে X মেলে, যদি তার পরবর্তী অংশে Y মেলে।
2. Negative Lookahead (?!...):
   • এটি চেক করে যে পরবর্তী অংশে প্যাটার্নটি মেলেনি কিনা।
   • Syntax: X(?!Y) - যেখানে X মেলে, যদি তার পরবর্তী অংশে Y না মেলে।
3. Positive Lookbehind (?<=...):
   • এটি চেক করে যে পূর্ববর্তী অংশে প্যাটার্নটি মিলে কিনা।
   • Syntax: (?<=Y)X - যেখানে X মেলে, যদি তার আগে Y মেলে।
4. Negative Lookbehind (?<!...):
   • এটি চেক করে যে পূর্ববর্তী অংশে প্যাটার্নটি মেলেনি কিনা।
   • Syntax: (?<!Y)X - যেখানে X মেলে, যদি তার আগে Y না মেলে।

উদাহরণ:

1. Positive Lookahead (The word should be followed by a space):

import java.util.regex.*;

public class LookaheadExample {
    public static void main(String[] args) {
        // Regex pattern with positive lookahead
        String pattern = "\\w+(?=\\s)"; // Word followed by space

        // String to search
        String text = "hello world";

        // Compile the pattern
        Pattern p = Pattern.compile(pattern);

        // Create a matcher
        Matcher m = p.matcher(text);

        // Check if the pattern matches
        while (m.find()) {
            System.out.println("Found: " + m.group());
        }
    }
}

আউটপুট:

Found: hello

ব্যাখ্যা:

• \\w+(?=\\s) এ \\w+ একটি বা একাধিক শব্দ ক্যারেক্টার এবং (?=\\s) positive lookahead চেক করে যে শব্দটি একটি স্পেসের পরে আসে।

2. Negative Lookahead (Word not followed by space):

import java.util.regex.*;

public class NegativeLookaheadExample {
    public static void main(String[] args) {
        // Regex pattern with negative lookahead
        String pattern = "\\w+(?!\\s)"; // Word not followed by space

        // String to search
        String text = "hello world";

        // Compile the pattern
        Pattern p = Pattern.compile(pattern);

        // Create a matcher
        Matcher m = p.matcher(text);

        // Check if the pattern matches
        while (m.find()) {
            System.out.println("Found: " + m.group());
        }
    }
}

আউটপুট:

Found: hello
Found: world

ব্যাখ্যা:

• \\w+(?!\\s) এ \\w+ শব্দটি চেক করে এবং (?!\\s) negative lookahead চেক করে যে শব্দটি স্পেস দ্বারা অনুসৃত নয়।

3. Positive Lookbehind (Word preceded by "hello"):

import java.util.regex.*;

public class LookbehindExample {
    public static void main(String[] args) {
        // Regex pattern with positive lookbehind
        String pattern = "(?<=hello )\\w+"; // Word preceded by "hello"

        // String to search
        String text = "hello world";

        // Compile the pattern
        Pattern p = Pattern.compile(pattern);

        // Create a matcher
        Matcher m = p.matcher(text);

        // Check if the pattern matches
        if (m.find()) {
            System.out.println("Found: " + m.group());
        }
    }
}

আউটপুট:

Found: world

ব্যাখ্যা:

• (?<=hello )\\w+ এ \\w+ শব্দটি চেক করে এবং (?<=hello ) positive lookbehind চেক করে যে শব্দটি "hello " এর পরে আসছে।

4. Negative Lookbehind (Word not preceded by "hello"):

import java.util.regex.*;

public class NegativeLookbehindExample {
    public static void main(String[] args) {
        // Regex pattern with negative lookbehind
        String pattern = "(?<!hello )\\w+"; // Word not preceded by "hello"

        // String to search
        String text = "hi world";

        // Compile the pattern
        Pattern p = Pattern.compile(pattern);

        // Create a matcher
        Matcher m = p.matcher(text);

        // Check if the pattern matches
        if (m.find()) {
            System.out.println("Found: " + m.group());
        }
    }
}

আউটপুট:

Found: hi

ব্যাখ্যা:

• (?<!hello )\\w+ এ \\w+ শব্দটি চেক করে এবং (?<!hello ) negative lookbehind চেক করে যে শব্দটি "hello " এর আগে নেই।

• Backreferences এবং Lookaround Assertions হল Java Regular Expressions এর দুটি শক্তিশালী ফিচার যা আপনাকে আরও জটিল এবং উন্নত প্যাটার্ন তৈরি করতে সাহায্য করে।
• Backreferences ব্যবহারে একটি প্যাটার্নের মধ্যে আগের একটি অংশ পুনরায় ব্যবহার করা হয়।
• Lookaround Assertions আপনাকে প্যাটার্নের আগে বা পরে কোনো শর্ত মেলানো/না মেলানো পরীক্ষা করতে সাহায্য করে, কিন্তু এটি সেই অংশটি অন্তর্ভুক্ত করে না।
• Java Regex এ এগুলোর ব্যবহার আপনাকে text validation, complex searching, data extraction, এবং advanced pattern matching আরও সহজ ও শক্তিশালী করে তোলে।

Backreference হল একটি ধারণা যা Regular Expressions (Regex)-এ ব্যবহৃত হয়, যেখানে আপনি একটি নির্দিষ্ট প্যাটার্নের অংশ পুনরায় রেফারেন্স করতে পারেন। Backreference ব্যবহারের মাধ্যমে আপনি group নামক অংশের মান পুনরায় ব্যবহার করতে পারেন যা একটি প্যাটার্নে ম্যাচ করা হয়। Java-তে রেগুলার এক্সপ্রেশন এবং backreference সাধারণত Pattern এবং Matcher ক্লাসের মাধ্যমে ব্যবহৃত হয়।

Backreference in Regular Expressions

1. Group Matching:
   • রেগুলার এক্সপ্রেশন ব্যবহার করার সময়, আপনি একটি প্যাটার্নে group ব্যবহার করতে পারেন, যা প্যাটার্নের কিছু অংশকে আলাদাভাবে ক্যাপচার করে রাখে। এটি সাধারণত প্যারেন্টেসিস () দিয়ে নির্দিষ্ট করা হয়।
2. Backreference:
   • যখন একটি গ্রুপের অংশ ম্যাচ হয়, তখন সেই অংশের মান \1, \2, \3, ... (যেমন একাধিক গ্রুপের ক্ষেত্রে) রেফারেন্স করে আনা যায়। \1 প্রথম গ্রুপের মান, \2 দ্বিতীয় গ্রুপের মান ইত্যাদি।
   • এটি মূলত একটি রেফারেন্স হিসেবে কাজ করে, যেখানে আপনি একটি নির্দিষ্ট গ্রুপের মান পুনরায় ব্যবহার করতে পারেন।

Backreference কাজ করার উদাহরণ:

ধরা যাক, আপনার একটি স্ট্রিং আছে যেখানে আপনি একই ধরনের দুটি শব্দের একে অপরের পরে পুনরাবৃত্তি (duplicate) বা রিপিট করতে চান, এবং আপনি backreference ব্যবহার করে সেটি খুঁজে বের করতে চান।

উদাহরণ 1: এক বা একাধিক গ্রুপের মাধ্যমে backreference

import java.util.regex.*;

public class BackreferenceExample {
    public static void main(String[] args) {
        // Regular expression with backreference
        String regex = "(\\b\\w+\\b)\\s+\\1";  // This matches two identical words in a row
        String input = "hello hello world java java world";

        // Compile regex pattern
        Pattern pattern = Pattern.compile(regex);
        
        // Create a matcher
        Matcher matcher = pattern.matcher(input);

        // Find matching words
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

কোড বিশ্লেষণ:

1. Regular Expression: (\\b\\w+\\b)\\s+\\1
   • (\\b\\w+\\b) হল একটি গ্রুপ যা একটি শব্দকে মেচ করে (যেমন "hello", "world", "java")।
   • \\s+ হলো স্পেস বা হোয়াইটস্পেস, যা দুইটি শব্দের মধ্যে থাকে।
   • \\1 backreference হিসেবে ব্যবহৃত হচ্ছে, যা প্রথম গ্রুপের শব্দটি পুনরায় ম্যাচ করবে।
2. Pattern.matcher(input): এটি ইনপুট স্ট্রিংয়ের সাথে প্যাটার্ন মেচ করে এবং যদি দুটি সমান শব্দ একে অপরের পর আসে তবে তা ম্যাচ হবে।
3. matcher.find(): এটি প্রতিটি মেলা অংশ খুঁজে বের করে এবং মেলানো অংশের মান প্রিন্ট করে।

আউটপুট:

Matched: hello hello
Matched: java java

এখানে, backreference \1 প্রথম গ্রুপের শব্দ ("hello" এবং "java") পুনরায় মেলানো হয় এবং দুটি শব্দ একে অপরের পর পুনরায় উপস্থিত হয়।

Backreference in Replace All (Replacer) Example:

backreference কেবলমাত্র মাচিং নয়, বরং স্ট্রিং পরিবর্তন (replacement) করার জন্যও ব্যবহার করা যায়।

import java.util.regex.*;

public class ReplaceBackreferenceExample {
    public static void main(String[] args) {
        String regex = "(\\b\\w+\\b)\\s+\\1";  // Matches duplicate words
        String input = "hello hello world java java world";

        // Replace using backreference
        String replaced = input.replaceAll(regex, "$1");

        System.out.println("Replaced String: " + replaced);
    }
}

কোড বিশ্লেষণ:

1. replaceAll(regex, "$1"): এটি regex প্যাটার্ন অনুযায়ী স্ট্রিংয়ের সমস্ত মেলানো অংশকে $1 দিয়ে প্রতিস্থাপন করে। $1 এখানে প্রথম গ্রুপের মানকে রিপ্লেস করবে এবং রিপিটেড শব্দ সরিয়ে ফেলবে।

আউটপুট:

Replaced String: hello world java world

এখানে, backreference $1 প্রথম গ্রুপের মান (যেমন "hello" এবং "java") নিয়ে রিপিটেড অংশ মুছে ফেলা হয়েছে।

Backreference এর অন্যান্য ব্যবহার:

1. Matching Palindromes:
   • আপনি backreference ব্যবহার করে প্যালিনড্রোম (palindromes) চেক করতে পারেন, যেখানে একটি শব্দ বা প্যাটার্ন উল্টো থেকে পড়লেও একই থাকে।
2. Pattern Grouping and Matching:
   • Grouping এবং matching এর ক্ষেত্রে backreference একটি শক্তিশালী টুল। আপনি প্রথম গ্রুপের সাথে ম্যাচ করার জন্য পরবর্তী অংশে একই প্যাটার্ন চেক করতে পারেন।
3. String Validation:
   • আপনি backreference ব্যবহার করে স্ট্রিং ভ্যালিডেশন করতে পারেন, যেমন একই ধরনের ডেটা প্যাটার্ন পুনরায় আসা এবং নিশ্চিত করা।

Backreference এর সিক্যুয়েন্স:

• \1, \2, \3: এগুলো রিপ্রেজেন্ট করে প্রথম, দ্বিতীয়, তৃতীয় গ্রুপের ম্যাচ। প্রতিটি গ্রুপ একটি নির্দিষ্ট অংশকে নির্দেশ করে এবং এই অংশের মান পরবর্তী প্যাটার্নে পুনরায় ব্যবহৃত হয়।

সারাংশ:

Backreference একটি রেগুলার এক্সপ্রেশন কৌশল, যা আপনাকে একটি গ্রুপের মান পরে প্যাটার্নে পুনরায় ব্যবহার করতে দেয়। এটি বিভিন্ন প্রয়োজনে যেমন স্ট্রিং পরিবর্তন, ডেটা ভ্যালিডেশন, প্যাটার্ন মাচিং ইত্যাদিতে ব্যবহৃত হয়। Java-তে Pattern এবং Matcher ক্লাস ব্যবহার করে আপনি সহজেই backreference এর মাধ্যমে প্যাটার্নের অংশ পুনরায় ব্যবহার করতে পারেন এবং স্ট্রিং পরিবর্তন বা ম্যানিপুলেট করতে পারেন।

Lookahead এবং Lookbehind Assertions হল regular expressions (regex) এর গুরুত্বপূর্ণ অংশ যা ব্যবহারকারীকে টেক্সটের নির্দিষ্ট অংশে মাচিং বা যাচাই করার জন্য সাহায্য করে, কিন্তু তারা যেখানেই মাচিং করুক না কেন, তাদের নিজস্ব মাচিং আউটপুটে অংশগ্রহণ করে না। এগুলো সাধারণত assertions হিসাবে পরিচিত, এবং এগুলি টেক্সটের আগে বা পরে কিছু অংশ থাকা দরকার, কিন্তু সেই অংশটি মাচিংয়ের অংশ হিসেবে গণনা করা হয় না।

Lookahead Assertions

Lookahead Assertions মূলত একটি প্যাটার্নের পরে কিছু শর্ত (condition) পরীক্ষা করতে ব্যবহৃত হয়, কিন্তু সেই শর্তের অংশটিকে মাচিং হিসেবে ধরবে না। এটি আপনাকে পরীক্ষা করতে সাহায্য করে যে একটি প্যাটার্নটি অন্য প্যাটার্নের আগে বা পরে উপস্থিত আছে কিনা।

Positive Lookahead:

• Positive Lookahead প্যাটার্নটি বলে যে, একটি নির্দিষ্ট প্যাটার্ন পরবর্তী কোনো অবস্থানে উপস্থিত হতে হবে, কিন্তু তা মাচিংয়ের অংশ হবে না।
• সিনট্যাক্স: X(?=Y)
  • এখানে, X হল আপনার মূল প্যাটার্ন এবং (?=Y) হল positive lookahead, যা নির্দেশ করে যে X এর পর Y থাকতে হবে।

উদাহরণ:

import java.util.regex.*;

public class PositiveLookaheadExample {
    public static void main(String[] args) {
        String regex = "\\d(?=\\D)"; // A digit followed by a non-digit character
        String input = "123a 456b 789c";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        
        while (matcher.find()) {
            System.out.println("Match: " + matcher.group());
        }
    }
}

আউটপুট:

Match: 1
Match: 4
Match: 7

কোড বিশ্লেষণ:

• \\d(?=\\D) এই রেগুলার এক্সপ্রেশনটি নির্দেশ করে যে \\d (একটি ডিজিট) এমনভাবে মাচ করতে হবে যে তার পরবর্তী চরিত্রটি কোনো ডিজিট নয় (\\D)।
• এটি "123a" থেকে 1, "456b" থেকে 4, এবং "789c" থেকে 7 কে মাচ করেছে, কারণ প্রত্যেকটি ডিজিটের পর একটি অ-ডিজিট রয়েছে।

Negative Lookahead:

• Negative Lookahead প্যাটার্নটি বলে যে, একটি নির্দিষ্ট প্যাটার্ন পরবর্তী কোনো অবস্থানে উপস্থিত হবে না। এটি negative assertion হিসেবে কাজ করে।
• সিনট্যাক্স: X(?!Y)
  • এখানে, X হল আপনার মূল প্যাটার্ন এবং (?!Y) হল negative lookahead, যা নির্দেশ করে যে X এর পর Y উপস্থিত হবে না।

উদাহরণ:

import java.util.regex.*;

public class NegativeLookaheadExample {
    public static void main(String[] args) {
        String regex = "\\d(?!\\d)"; // A digit not followed by another digit
        String input = "123a 456b 789";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        
        while (matcher.find()) {
            System.out.println("Match: " + matcher.group());
        }
    }
}

আউটপুট:

Match: 3
Match: 6
Match: 9

কোড বিশ্লেষণ:

• \\d(?!\\d) এই রেগুলার এক্সপ্রেশনটি বলে যে, একটি ডিজিটের পর কোনো আরেকটি ডিজিট থাকতে পারবে না।
• এটি "123a" থেকে 3, "456b" থেকে 6, এবং "789" থেকে 9 মাচ করেছে কারণ তারা তাদের পরবর্তী ডিজিট ছাড়া আসে।

Lookbehind Assertions

Lookbehind Assertions এমন একটি প্যাটার্ন যা চেক করে যে কোনও নির্দিষ্ট প্যাটার্ন একটি নির্দিষ্ট অবস্থানের আগে উপস্থিত ছিল কিনা। এটি দুটি ধরনের হতে পারে:

Positive Lookbehind:

• Positive Lookbehind প্যাটার্নটি বলে যে, একটি প্যাটার্ন একটি নির্দিষ্ট অবস্থানের আগে উপস্থিত থাকতে হবে।
• সিনট্যাক্স: (?<=Y)X
  • এখানে, X হল আপনার মূল প্যাটার্ন এবং (?<=Y) হল positive lookbehind, যা নির্দেশ করে যে Y এর আগে X উপস্থিত থাকতে হবে।

উদাহরণ:

import java.util.regex.*;

public class PositiveLookbehindExample {
    public static void main(String[] args) {
        String regex = "(?<=@)\\w+"; // Match word after '@'
        String input = "email@example.com contact@domain.com";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        
        while (matcher.find()) {
            System.out.println("Match: " + matcher.group());
        }
    }
}

আউটপুট:

Match: example
Match: domain

কোড বিশ্লেষণ:

• (?<=@)\\w+ এই রেগুলার এক্সপ্রেশনটি বলে যে, @ চিহ্নের পরে যেকোনো শব্দ মাচ করতে হবে।
• এটি email@example.com থেকে example এবং contact@domain.com থেকে domain মাচ করেছে।

Negative Lookbehind:

• Negative Lookbehind প্যাটার্নটি বলে যে, একটি প্যাটার্ন একটি নির্দিষ্ট অবস্থানের আগে উপস্থিত হবে না।
• সিনট্যাক্স: (?<!Y)X
  • এখানে, X হল আপনার মূল প্যাটার্ন এবং (?<!Y) হল negative lookbehind, যা নির্দেশ করে যে X এর আগে Y থাকতে পারবে না।

উদাহরণ:

import java.util.regex.*;

public class NegativeLookbehindExample {
    public static void main(String[] args) {
        String regex = "(?<!@)\\w+"; // Match words not preceded by '@'
        String input = "email@example.com contact@domain.com hello world";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        
        while (matcher.find()) {
            System.out.println("Match: " + matcher.group());
        }
    }
}

আউটপুট:

Match: hello
Match: world

কোড বিশ্লেষণ:

• (?<!@)\\w+ এই রেগুলার এক্সপ্রেশনটি বলে যে, যদি একটি শব্দের আগে @ না থাকে, তবে সেটি মাচ করতে হবে।
• এটি "hello world" থেকে hello এবং world মাচ করেছে, কারণ তাদের আগে @ নেই।

Lookahead এবং Lookbehind Assertions এর ব্যবহার:

1. Complex Pattern Matching:
   • Lookahead এবং Lookbehind Assertions আপনাকে স্ট্রিংয়ের নির্দিষ্ট অংশে মাচিং বা যাচাই করতে সাহায্য করে, যেমন একটি স্ট্রিংয়ের আগে বা পরে কিছু নির্দিষ্ট শর্ত আছে কিনা।
2. Text Validation:
   • এগুলো সাধারণত input validation বা format validation এ ব্যবহৃত হয়, যেমন কোনো ফরম্যাটে থাকা ইমেইল, ফোন নম্বর, বা পাসওয়ার্ড চেক করা।
3. Excluding Certain Patterns:
   • Negative Lookahead এবং Negative Lookbehind এর সাহায্যে আপনি স্ট্রিং থেকে নির্দিষ্ট অংশ বাদ দিতে পারেন, যেমন কিছু শব্দের আগে বা পরে কিছু নির্দিষ্ট প্যাটার্ন নেই তা নিশ্চিত করা।

Lookahead এবং Lookbehind Assertions আপনাকে Java Regular Expressions এ অত্যন্ত শক্তিশালী প্যাটার্ন মাচিং সক্ষমতা প্রদান করে। Lookahead (positive এবং negative) এবং Lookbehind (positive এবং negative) স্ট্রিংয়ের নির্দিষ্ট অবস্থান চেক করতে সাহায্য করে, যা টেক্সট প্রক্রিয়ায় খুবই উপকারী হতে পারে।

Java Reflection প্যাকেজটি Java Regex (Regular Expressions)-এর জন্য সরাসরি ব্যবহৃত হয় না, তবে রেগুলার এক্সপ্রেশন (regex) প্যাটার্ন তৈরি করতে Pattern এবং Matcher ক্লাস ব্যবহার হয়। Positive Lookahead এবং Negative Lookahead, Positive Lookbehind এবং Negative Lookbehind হল জাভা রেগুলার এক্সপ্রেশনের গুরুত্বপূর্ণ কনসেপ্ট, যা স্ট্রিংয়ের ভিতরে একটি নির্দিষ্ট প্যাটার্নের উপস্থিতি বা অনুপস্থিতি চিহ্নিত করতে ব্যবহৃত হয়। এগুলি রেগুলার এক্সপ্রেশন প্যাটার্নের জন্য assertion হিসেবে কাজ করে, যা নির্দিষ্ট প্যাটার্নের আগে বা পরে কোনো কিছু থাকা প্রয়োজন বা নিষিদ্ধ কিনা তা পরীক্ষা করে।

1. Positive Lookahead ((?=...)):

Positive Lookahead চেক করে যে একটি নির্দিষ্ট প্যাটার্ন একটি নির্দিষ্ট অবস্থানের পরে উপস্থিত রয়েছে কিনা, কিন্তু এটি সেই প্যাটার্নকে ম্যাচ হিসেবে অন্তর্ভুক্ত করে না। এটি "ahead" (পরে) চেক করে এবং প্যাটার্নটি মেলানোর জন্য অবশ্যই ঐ অবস্থানে উপস্থিত থাকতে হবে।

ব্যবহার:

(?=...)  // Positive Lookahead

উদাহরণ:

import java.util.regex.*;

public class PositiveLookaheadExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("a(?=b)");
        Matcher matcher = pattern.matcher("abc");

        // find() মেথড ব্যবহার
        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}

Output:

Match found at index: 0

ব্যাখ্যা:

• a(?=b) প্যাটার্নটি a কে খুঁজে, তবে শুধুমাত্র তখনই মেলে যখন তার পরবর্তী চরিত্র b থাকে। এখানে a এবং b একসাথে মেলানো হচ্ছে, কিন্তু b প্যাটার্নের অংশ হিসেবে গণ্য হচ্ছে না।

2. Negative Lookahead ((?!...)):

Negative Lookahead চেক করে যে একটি নির্দিষ্ট প্যাটার্ন একটি নির্দিষ্ট অবস্থানের পরে উপস্থিত না থাকে, এটি নিশ্চিত করে যে সেই অবস্থানের পরে প্যাটার্নটি থাকবে না। এটি "ahead" (পরে) চেক করে এবং যদি প্যাটার্নটি সেখানে না থাকে, তবে ম্যাচ সফল হয়।

ব্যবহার:

(?!...)  // Negative Lookahead

উদাহরণ:

import java.util.regex.*;

public class NegativeLookaheadExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("a(?!b)");
        Matcher matcher = pattern.matcher("ac abc ab");

        // find() মেথড ব্যবহার
        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}

Output:

Match found at index: 0
Match found at index: 3

ব্যাখ্যা:

• a(?!b) প্যাটার্নটি a কে খুঁজে এবং মেলে না যদি তার পরে b থাকে। ac এবং ab এ a এর মধ্যে পার্থক্য রয়েছে এবং প্রথমটি মেলে, তবে দ্বিতীয়টি মেলেনা কারণ ab-এর পর b রয়েছে।

3. Positive Lookbehind ((?<=...)):

Positive Lookbehind চেক করে যে একটি নির্দিষ্ট প্যাটার্ন একটি নির্দিষ্ট অবস্থানের আগে উপস্থিত রয়েছে কিনা, কিন্তু এটি সেই প্যাটার্নকে ম্যাচ হিসেবে অন্তর্ভুক্ত করে না। এটি "behind" (আগে) চেক করে এবং প্যাটার্নটি মেলানোর জন্য অবশ্যই ঐ অবস্থানের আগে উপস্থিত থাকতে হবে।

ব্যবহার:

(?<=...)  // Positive Lookbehind

উদাহরণ:

import java.util.regex.*;

public class PositiveLookbehindExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(?<=a)b");
        Matcher matcher = pattern.matcher("ab acb abc");

        // find() মেথড ব্যবহার
        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}

Output:

Match found at index: 1
Match found at index: 4

ব্যাখ্যা:

• (?<=a)b প্যাটার্নটি b কে খুঁজে, তবে শুধুমাত্র যখন তার আগে a থাকে। প্রথম এবং দ্বিতীয় b-এর আগে a রয়েছে, তাই মেলে।

4. Negative Lookbehind ((?<!...)):

Negative Lookbehind চেক করে যে একটি নির্দিষ্ট প্যাটার্ন একটি নির্দিষ্ট অবস্থানের আগে উপস্থিত না থাকে, এটি নিশ্চিত করে যে সেই অবস্থানের আগে প্যাটার্নটি থাকবে না। এটি "behind" (আগে) চেক করে এবং যদি প্যাটার্নটি সেখানে না থাকে, তবে ম্যাচ সফল হয়।

ব্যবহার:

(?<!...)  // Negative Lookbehind

উদাহরণ:

import java.util.regex.*;

public class NegativeLookbehindExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(?<!a)b");
        Matcher matcher = pattern.matcher("ab acb abc");

        // find() মেথড ব্যবহার
        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}

Output:

Match found at index: 4

ব্যাখ্যা:

• (?<!a)b প্যাটার্নটি b কে খুঁজে, তবে শুধুমাত্র যখন তার আগে a না থাকে। দ্বিতীয় b মেলে, কারণ এর আগে a নেই, কিন্তু প্রথম b মেলেনা কারণ তার আগে a রয়েছে।

Lookahead এবং Lookbehind এর তুলনা:

• Lookahead এবং Lookbehind রেগুলার এক্সপ্রেশনে বিশেষভাবে assertion হিসেবে ব্যবহৃত হয়, যা স্ট্রিংয়ের ভিতরে কিছু প্যাটার্নের উপস্থিতি বা অনুপস্থিতি চিহ্নিত করে।
• Positive Lookahead ( (?=...) ) এবং Negative Lookahead ( (?!...) ) পরবর্তী অবস্থানের চেক করে।
• Positive Lookbehind ( (?<=...) ) এবং Negative Lookbehind ( (?<!...) ) পূর্ববর্তী অবস্থানের চেক করে।
• এই কনসেপ্টগুলি স্ট্রিংয়ের মধ্যে প্যাটার্নের সঠিক অবস্থান চিহ্নিত করতে অত্যন্ত শক্তিশালী টুল হিসেবে কাজ করে।

Backreferences এবং Lookaround রেগুলার এক্সপ্রেশন (Regex) এর গুরুত্বপূর্ণ টুলস যা বিশেষভাবে স্ট্রিং ম্যাচিং এবং প্যাটার্ন খুঁজতে কাজে আসে। জাভা রেগুলার এক্সপ্রেশন প্যাটার্নে এই দুটি বৈশিষ্ট্য ব্যবহার করা সম্ভব। আসুন দেখি তাদের ব্যবহারিক উদাহরণ:

1. Backreferences

Backreference রেগুলার এক্সপ্রেশনে ব্যবহার হয় যখন আপনি একটি প্যাটার্নের অংশ পুনরায় রেফারেন্স করতে চান। এটি সাধারণত একটি গ্রুপ (উদাহরণস্বরূপ, কৌনিক বন্ধনী () এর মধ্যে) দ্বারা তৈরি করা হয়, এবং পরে সেই গ্রুপের ম্যাচ করা অংশকে পুনরায় রেফারেন্স করা হয়।

ব্যবহার:

• Backreferences রেগুলার এক্সপ্রেশন ব্যবহার করে, আপনি একটি স্ট্রিংয়ে যে কোনও সাবস্ট্রিং যেখানে একই ডাটা পুনরায় এসেছে তা খুঁজে বের করতে পারেন।

ব্যবহারিক উদাহরণ:

ধরা যাক, আমরা একটি স্ট্রিং চেক করতে চাই যেখানে দুটি শব্দের মধ্যে একই শব্দ পুনরায় ব্যবহার হয়েছে।

import java.util.regex.*;

public class BackreferenceExample {
    public static void main(String[] args) {
        String regex = "(\\b\\w+\\b)\\s+\\1";  // একটি শব্দ পুনরায় আসছে
        String text1 = "Hello Hello";
        String text2 = "Hello World";
        
        // Pattern তৈরি করুন
        Pattern pattern = Pattern.compile(regex);
        
        // Matcher তৈরি করুন
        Matcher matcher1 = pattern.matcher(text1);
        Matcher matcher2 = pattern.matcher(text2);
        
        // মেলানো হচ্ছে কিনা চেক করুন
        System.out.println("Does text1 match? " + matcher1.matches());  // true
        System.out.println("Does text2 match? " + matcher2.matches());  // false
    }
}

ব্যাখ্যা:

• "(\\b\\w+\\b)\\s+\\1": এখানে \\b\\w+\\b দিয়ে একটি শব্দ এবং \\1 দিয়ে প্রথম গ্রুপের পুনরাবৃত্তি (backreference) দেখানো হয়েছে।
• text1 = "Hello Hello" স্ট্রিংটি প্রথম শব্দ "Hello" পুনরায় এসেছে, তাই এটি মিলে যাবে। কিন্তু text2 = "Hello World" স্ট্রিংয়ে এমন কিছু নেই, তাই এটি ম্যাচ করবে না।

আউটপুট:

Does text1 match? true
Does text2 match? false

2. Lookaround

Lookaround হল রেগুলার এক্সপ্রেশনের একটি শক্তিশালী ফিচার যা আপনাকে স্ট্রিংয়ের একটি অংশের আগে বা পরে কী হতে পারে তা চেক করতে দেয়, কিন্তু সেই অংশটি ম্যাচ করা হয় না। এতে দুটি প্রকার আছে:

• Positive Lookahead ((?=...)): চেক করে যে একটি নির্দিষ্ট প্যাটার্ন পরবর্তীতে থাকবে কিনা।
• Negative Lookahead ((?!...)): চেক করে যে একটি নির্দিষ্ট প্যাটার্ন পরবর্তীতে থাকবে না।
• Positive Lookbehind ((?<=...)): চেক করে যে একটি নির্দিষ্ট প্যাটার্ন পূর্বে ছিল কিনা।
• Negative Lookbehind ((?<!...)): চেক করে যে একটি নির্দিষ্ট প্যাটার্ন পূর্বে ছিল না।

ব্যবহারিক উদাহরণ:

ধরা যাক, আমরা একটি স্ট্রিং চেক করতে চাই যেখানে কোনও সংখ্যা ফলে আছে এবং তার পরে একটি d (ধরা যাক: "end") শব্দটি রয়েছে।

import java.util.regex.*;

public class LookaroundExample {
    public static void main(String[] args) {
        String regex = "\\d(?= end)";  // একটি সংখ্যা যা "end" শব্দের আগে থাকবে
        String text1 = "I have 5 end here";
        String text2 = "I have 5 here";
        
        // Pattern তৈরি করুন
        Pattern pattern = Pattern.compile(regex);
        
        // Matcher তৈরি করুন
        Matcher matcher1 = pattern.matcher(text1);
        Matcher matcher2 = pattern.matcher(text2);
        
        // মেলানো হচ্ছে কিনা চেক করুন
        System.out.println("Does text1 match? " + matcher1.find());  // true
        System.out.println("Does text2 match? " + matcher2.find());  // false
    }
}

ব্যাখ্যা:

• \\d(?= end) প্যাটার্নটি চেক করে যে একটি সংখ্যা (ডিজিট) "end" শব্দের আগে আছে, কিন্তু "end" শব্দটি স্ট্রিংয়ের অংশ হিসেবে ম্যাচ হবে না, শুধু সংখ্যা ম্যাচ করবে।
• text1 = "I have 5 end here" স্ট্রিংয়ে "5" সংখ্যা "end" এর আগে আছে, তাই এটি ম্যাচ করবে।
• text2 = "I have 5 here" স্ট্রিংয়ে "5" এর পরে "end" নেই, তাই এটি ম্যাচ করবে না।

আউটপুট:

Does text1 match? true
Does text2 match? false

Negative Lookahead Example:

ধরা যাক, আমরা এমন একটি স্ট্রিং চেক করতে চাই যেখানে কোনও শব্দ "hello" এর পরে "world" শব্দটি না থাকে।

import java.util.regex.*;

public class LookaroundExample2 {
    public static void main(String[] args) {
        String regex = "hello(?! world)";  // hello এর পরে world না থাকা
        String text1 = "hello there";
        String text2 = "hello world";
        
        // Pattern তৈরি করুন
        Pattern pattern = Pattern.compile(regex);
        
        // Matcher তৈরি করুন
        Matcher matcher1 = pattern.matcher(text1);
        Matcher matcher2 = pattern.matcher(text2);
        
        // মেলানো হচ্ছে কিনা চেক করুন
        System.out.println("Does text1 match? " + matcher1.find());  // true
        System.out.println("Does text2 match? " + matcher2.find());  // false
    }
}

ব্যাখ্যা:

• hello(?! world) প্যাটার্নটি "hello" শব্দের পরে "world" শব্দটি না থাকা চেক করে।
• text1 = "hello there" স্ট্রিংয়ে "hello" শব্দের পরে "world" নেই, তাই এটি ম্যাচ করবে।
• text2 = "hello world" স্ট্রিংয়ে "hello" শব্দের পরে "world" রয়েছে, তাই এটি ম্যাচ করবে না।

আউটপুট:

Does text1 match? true
Does text2 match? false

1. Backreferences: আপনি যখন রেগুলার এক্সপ্রেশনে এক বা একাধিক গ্রুপ ব্যবহার করেন এবং সেই গ্রুপের একই অংশের পুনরাবৃত্তি চাইলে backreference ব্যবহার করেন। এটি স্ট্রিংয়ের মধ্যে পুনরায় একই অংশ খুঁজতে সাহায্য করে।
2. Lookaround: এটি একটি শক্তিশালী বৈশিষ্ট্য যা স্ট্রিংয়ের একটি অংশের আগে বা পরে নির্দিষ্ট প্যাটার্ন থাকার শর্তে ম্যাচিং করতে সাহায্য করে।
   • Positive Lookahead ((?=...)): চেক করে যে কিছু পরবর্তী থাকবে।
   • Negative Lookahead ((?!...)): চেক করে যে কিছু পরবর্তী থাকবে না।
   • Positive Lookbehind ((?<=...)): চেক করে যে কিছু পূর্বে ছিল।
   • Negative Lookbehind ((?<!...)): চেক করে যে কিছু পূর্বে ছিল না।

এই সমস্ত টুলগুলি আপনাকে স্ট্রিংয়ে আরও নির্দিষ্ট এবং জটিল প্যাটার্ন খুঁজে বের করতে সাহায্য করে।