regular expression — Pattern আর Matcher দিয়ে লেখা খোঁজা, যাচাই আর বদলানো

১ · regular expression কী — এক পাতা if-এর বদলে এক লাইনের নকশা

ধরুন একটি ফর্মে ব্যবহারকারী মোবাইল নম্বর লিখবেন। আপনাকে যাচাই করতে হবে নম্বরটি বাংলাদেশি মোবাইল নম্বরের মতো দেখতে কি না। নিয়মটি মুখে বললে এরকম: “প্রথমে ০, তারপর ১, তারপর ৩ থেকে ৯-এর যেকোনো একটি অঙ্ক, তারপর ঠিক আটটি অঙ্ক, আর কিছু নয়।”

এখন পর্যন্ত যা শিখেছেন তা দিয়েই এটি লেখা যায়: length() ১১ কি না, charAt(0) '0' কি না, charAt(2) '3' থেকে '9'-এর মধ্যে কি না, তারপর একটি লুপে বাকি আটটি ঘর অঙ্ক কি না। প্রায় পনেরো লাইন। এবার নিয়মে যোগ হলো “শুরুতে +880 থাকতেও পারে।” আরও দশ লাইন। তারপর “মাঝে হাইফেন বা ফাঁকা থাকলে মুছে দাও।” কোড বাড়তেই থাকে, আর প্রতিটি নতুন if-এর সাথে ভুলের সুযোগও বাড়ে।

একই নিয়ম regular expression (সংক্ষেপে regex) দিয়ে লিখলে:

Regex হলো লেখার আকৃতি বর্ণনা করার একটি ছোট ভাষা। এটি নিজে কোনো প্রোগ্রাম নয়; এটি একটি নকশা, যা একটি “ইঞ্জিন” লেখার সাথে মিলিয়ে দেখে। এই নকশা দিয়ে চার রকম কাজ হয়:

পর্ব ০৮-এ split, replaceAll আর matches-এর ভেতরে লুকানো regex-এর সাথে প্রথম দেখা হয়েছিল — সেখানে split(".") শূন্য দৈর্ঘ্যের array দিয়ে চমকে দিয়েছিল। এই পর্বে সেই লুকানো ভাষাটিকে সামনে এনে পুরোপুরি শিখব।

Java-তে দুই চরিত্র — Pattern আর Matcher

Java-র regex থাকে java.util.regex package-এ, Java 1.4 (২০০২) থেকে। সেখানে দুটি মূল class:

২ · নকশার বর্ণমালা — metacharacter, escaping আর Java-র ডাবল backslash

Regex-এ বেশিরভাগ অক্ষর নিজেকেই বোঝায়: a মানে a, 7 মানে 7, Tk মানে হুবহু “Tk”. কিন্তু ১৪টি অক্ষরের বিশেষ মানে আছে। এদের বলে metacharacter:

কোনো metacharacter-কে তার সাধারণ অর্থে চাইলে সামনে \ বসান: আসল ডট \., আসল যোগ চিহ্ন \+, আসল ব্র্যাকেট \(. এই কাজটিকে বলে escape করা।

Java-র বাড়তি ঝামেলা — backslash দুবার

এখানেই Java শিক্ষার্থীরা সবচেয়ে বেশি হোঁচট খান। regex-এর ভাষায় অঙ্ক মানে \d. কিন্তু আপনি regex লিখছেন একটি Java string literal-এর ভেতরে, আর Java String-এ \ নিজেই একটি escape sequence শুরু করে (\n, \t, পর্ব ০৪)। \d নামে কোনো Java escape নেই, তাই compiler আপত্তি করে (OpenJDK 21-এ যাচাই করা):

Main.java:3: error: illegal escape character
        System.out.println("01712345678".matches("01[3-9]\d{8}"));
                                                          ^

সমাধান: Java String-এ একটি আসল \ লিখতে হয় \\. ফলে দুই স্তরের অনুবাদ ঘটে — Java compiler "\\d" পড়ে মেমরিতে রাখে দুই অক্ষর \d, তারপর regex engine সেটি পড়ে বোঝে “একটি অঙ্ক”। আসল ডট চাইলে regex-এ \., Java-তে "\\.". আর একটি আসল backslash খুঁজতে চাইলে regex-এ \\, Java-তে চারটি: "\\\\".

লেখাটিকে হুবহু চাইলে — Pattern.quote

কখনো ব্যবহারকারীর দেওয়া লেখাকেই খুঁজতে হয়, যেমন কেউ সার্চ বক্সে লিখলেন 1+1. সেটি সরাসরি নকশা হিসেবে দিলে + quantifier হয়ে যাবে। Pattern.quote("1+1") লেখাটিকে \Q1+1\E-এ মুড়ে দেয় — \Q থেকে \E পর্যন্ত সবকিছু হুবহু অর্থে। তাই "192.168.0.1".split(Pattern.quote(".")) দেয় [192, 168, 0, 1]. বাইরে থেকে আসা লেখা দিয়ে নকশা বানালে সবসময় quote করুন; নইলে কেউ ইচ্ছা করে বা ভুলে এমন নকশা পাঠাতে পারেন, যা আপনার সার্ভারকে আটকে রাখে (অংশ ৮)।

ভুল নকশা — PatternSyntaxException

নকশার ব্যাকরণ ভুল হলে Java compile-এর সময় ধরে না, কারণ compiler-এর কাছে নকশাটি শুধুই একটি String. ধরা পড়ে চলার সময়, Pattern.compile (বা matches, split) ডাকার মুহূর্তে — PatternSyntaxException, একটি unchecked exception. যেমন Pattern.compile("01[3-9"), যেখানে ] বন্ধ করা হয়নি:

java.util.regex.PatternSyntaxException: Unclosed character class near index 5
01[3-9
     ^

বার্তাটি তিন অংশে: সমস্যার বিবরণ (Unclosed character class), কোন index-এর কাছে (৫ — নকশার শেষ অক্ষর 9), আর নকশার নিচে ^ দিয়ে জায়গাটি দেখানো। আরও দুটি পরিচিত বার্তা: "(abc" দিলে Unclosed group near index 4, আর "*abc" দিলে Dangling meta character '*' near index 0 — অর্থাৎ *-এর আগে এমন কিছু নেই যাকে সে পুনরাবৃত্তি করবে। (তিনটিই OpenJDK 21-এ যাচাই করা।)

৩ · character class আর quantifier — কোন অক্ষর, কতবার

Regex-এর প্রায় সব নকশা দুটি প্রশ্নের উত্তর: এখানে কোন অক্ষর বসতে পারে? আর কতবার? প্রথমটির উত্তর দেয় character class, দ্বিতীয়টির quantifier.

Character class-এর ভেতরে বেশিরভাগ metacharacter সাধারণ অক্ষর হয়ে যায়: [.+] মানে আসল ডট বা আসল যোগ চিহ্ন। ব্যতিক্রম চারটি — ], \, শুরুতে ^, আর মাঝখানে -. তাই হাইফেন রাখতে চাইলে শুরুতে বা শেষে রাখুন: [\s-].

Quantifier শুধু তার ঠিক আগের জিনিসটির ওপর কাজ করে। ab+ মানে “a, তারপর এক বা একাধিক b” — “ab” পুনরাবৃত্তি নয়। পুরো “ab” পুনরাবৃত্তি চাইলে group: (ab)+.

Engine আসলে কী করে — অক্ষর ধরে ধরে হাঁটা

Regex engine একজন অত্যন্ত ধৈর্যশীল পাহারাদারের মতো। সে লেখার শুরুতে দাঁড়ায়, নকশার প্রথম টুকরোটি দেখে, লেখার বর্তমান অক্ষর মেলে কি না যাচাই করে, মিললে দুজনেই এক ধাপ এগোয়। নিচে "01712345678".matches("^01[3-9]\\d{8}$") চলার সময় ঠিক কী হয়, দেখুন। “পরে” চাপুন:

1^        লেখার শুরু20        হুবহু 031        হুবহু 14[3-9]    3 থেকে 9-এর একটি5\d{8}    ঠিক ৮টি অঙ্ক6$        লেখার শেষ

৪ · greedy, reluctant আর possessive — quantifier কতটুকু খাবে

.+ মানে “এক বা একাধিক যেকোনো অক্ষর”। কিন্তু ঠিক কতগুলো? যতগুলো সম্ভব, নাকি যতগুলো দরকার? এই প্রশ্নের তিন রকম উত্তর আছে, আর ভুল উত্তর বেছে নেওয়াই regex-এর সবচেয়ে প্রচলিত বাগ।

• Greedy (*, +, ?, {n,m} — ডিফল্ট): greedy quantifier প্রথমে যত বেশি সম্ভব খায়, তারপর বাকি নকশা না মিললে একটি একটি করে ফেরত দেয়।
• Reluctant (পেছনে ?: *?, +?): reluctant quantifier (অন্য ভাষায় lazy) যত কম সম্ভব খায়, দরকার হলে একটি একটি করে বাড়ায়।
• Possessive (পেছনে +: *+, ++): possessive quantifier যত বেশি সম্ভব খায় এবং কখনো ফেরত দেয় না।

এই “ফেরত দেওয়া” বা পিছিয়ে এসে আবার চেষ্টা করাকে বলে backtracking. HTML-এর মতো লেখায় < আর >-এর মাঝের ট্যাগ খুঁজতে গিয়ে পার্থক্যটি চোখে পড়ে:

1Pattern.compile("<.+>")     // greedy2Pattern.compile("<.+?>")    // reluctant3Pattern.compile("<[^>]+>")  // negated class4Pattern.compile("<.++>")    // possessive

৫ · anchor, group আর তিন রকম মেলানো — matches, lookingAt, find

Anchor আর word boundary

^ আর $ অক্ষর নয়, অবস্থান। একইভাবে \b হলো word boundary — যেখানে একদিকে “শব্দের অক্ষর” (\w) আর অন্যদিকে নয়। \bcat\b “cat” শব্দটি খোঁজে, কিন্তু “category”-র ভেতরের cat নয়। একটি সূক্ষ্ম কথা: $ লেখার একেবারে শেষে তো মেলেই, শেষে একটি newline থাকলে তার আগেও মেলে। তাই find() দিয়ে ^\d+$ খুঁজলে "123\n"-এ মিল পাওয়া যায়; একদম শেষ চাইলে \z (যাচাই করা)। matches() অবশ্য পুরো লেখা চায়, তাই সেখানে newline-সহ লেখা মেলে না।

Group — কয়েকটি জিনিস এক করা, আর টুকরো মনে রাখা

বন্ধনী ( ) দুটি কাজ করে। এক, ভেতরের জিনিসগুলোকে একটি একক বানায়, যাতে quantifier বা | পুরোটার ওপর খাটে। দুই, মিলের সেই অংশটুকু মনে রাখে — একে বলে capturing group. বাঁ দিক থেকে খোলা বন্ধনী গুনে নম্বর হয় ১, ২, ৩…; group(0) বা শুধু group() মানে পুরো মিল।

Backreference-এর দুটি ছোট উদাহরণ (যাচাই করা): (\w)\1 “bookkeeper”-এ পায় oo, kk, ee — একই অক্ষর পরপর দুবার। আর "this is is a test test".replaceAll("\\b(\\w+)\\s+\\1\\b", "$1") দেয় this is a test — ভুলে দুবার লেখা শব্দ মুছে গেল। Alternation-এর অগ্রাধিকার সবচেয়ে কম: ^INFO|WARN$ মানে “শুরুতে INFO” অথবা “শেষে WARN”, তাই বিকল্পগুলো group-এ রাখুন: ^(?:INFO|WARN)$.

বাস্তব উদাহরণ — লগ লাইন ভাঙা, named group দিয়ে

সার্ভারের লগ ফাইলে লাইনগুলো এরকম: 2026-10-18 ERROR Payment gateway timeout. তারিখ, log level আর বার্তা আলাদা করতে:

Pattern LOG = Pattern.compile(
    "(?<date>\\d{4}-\\d{2}-\\d{2}) (?<level>INFO|WARN|ERROR) (?<msg>.*)");
Matcher m = LOG.matcher("2026-10-18 ERROR Payment gateway timeout");
if (m.matches()) {
    m.group("date");    // "2026-10-18"
    m.group("level");   // "ERROR"
    m.group("msg");     // "Payment gateway timeout"
    m.groupCount();     // 3
}

Named group-এর বড় সুবিধা হলো নকশায় নতুন group যোগ করলে নম্বর সরে যায়, নাম সরে না। m.groupCount() named group-ও গোনে, non-capturing গোনে না। আর মিল না পেয়ে group() ডাকলে IllegalStateException: No match found — তাই আগে matches() বা find()-এর ফল দেখে নিন।

তিন রকম মেলানো — সবচেয়ে বেশি ভুল হয় এখানে

(সব ফল OpenJDK 21-এ যাচাই করা।) String.matches(regex) হলো Pattern.matches-এর সংক্ষিপ্ত রূপ — পুরো লেখা। ফর্ম যাচাইয়ে সাধারণত এটিই চান। কিন্তু AI বা অন্য ভাষা থেকে আসা কোডে প্রায়ই দেখবেন যাচাইয়ের জন্য find() লেখা, নকশায় ^/$ নেই — ফলে “আমার নম্বর 01712345678, টাকা পাঠান” পুরো বাক্যটিই “বৈধ নম্বর” হয়ে যায়।

৬ · Matcher-এর লুপ, replaceAll আর split — তথ্য তোলা, বদলানো, কাটা

একটি মোবাইল ব্যাংকিং SMS-এর মতো লেখা ধরুন (বানানো নমুনা): You have received Tk 1,500.00 from 01712345678. Fee Tk 0.00. Balance Tk 12,340.50. TrxID 9JK4L2M8NP …. এখান থেকে সব টাকার অঙ্ক বের করতে চাই। নকশা: Tk ([\d,]+\.\d{2}) — “Tk, ফাঁকা, তারপর অঙ্ক বা কমা এক বা একাধিক, তারপর আসল ডট আর দুটি অঙ্ক”, বন্ধনীর ভেতরের অংশটি group 1. find() প্রতিবার ডাকলে আগের মিলের শেষ থেকে পরের মিল খোঁজে — তাই এটি একটি while লুপে চলে:

1Matcher m = AMOUNT.matcher(sms);2while (m.find()) {3    print(m.group(1), m.start(), m.end());4}5// লুপ শেষ

এবার পুরো কাজটি চালিয়ে দেখুন — টাকার অঙ্ক, named group দিয়ে TrxID, আর ফোন নম্বরের মাঝের অঙ্কগুলো ঢেকে দেওয়া:

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

class Main {
    static final Pattern AMOUNT = Pattern.compile("Tk ([\\d,]+\\.\\d{2})");
    static final Pattern TRX = Pattern.compile("TrxID (?<id>[A-Z0-9]{10})");

    public static void main(String[] args) {
        String sms = "You have received Tk 1,500.00 from 01712345678. Fee Tk 0.00. "
                   + "Balance Tk 12,340.50. TrxID 9JK4L2M8NP at 14/10/2026 10:15";
        Matcher m = AMOUNT.matcher(sms);
        while (m.find()) {
            double tk = Double.parseDouble(m.group(1).replace(",", ""));
            System.out.printf("%-9s index %2d-%2d -> %.2f%n", m.group(1), m.start(), m.end(), tk);
        }
        Matcher t = TRX.matcher(sms);
        if (t.find()) System.out.println("TrxID   = " + t.group("id"));
        String safe = sms.replaceAll("(01[3-9])\\d{5}(\\d{3})", "$1*****$2");
        System.out.println(safe.split("\\. ")[0]);
    }
}

replaceAll — $ আর \-এর বিশেষ মানে

replaceAll(regex, replacement)-এর প্রথম argument regex, আর দ্বিতীয়টিও পুরোপুরি সাধারণ লেখা নয়: সেখানে $1 মানে group 1, ${name} মানে named group, আর \ escape. ফলে বদলি লেখায় একটি আসল $ থাকলে বিপদ (OpenJDK 21-এ যাচাই করা):

"Tk 50".replaceAll("Tk", "$")   →  IllegalArgumentException: Illegal group reference: group index is missing
"Tk 50".replaceAll("Tk", "$5")  →  IndexOutOfBoundsException: No group 5

বদলি লেখাটি যদি বাইরে থেকে আসে (ব্যবহারকারী, ডেটাবেস, মুদ্রার চিহ্ন), তাহলে Matcher.quoteReplacement(text) দিয়ে মুড়ে দিন: "Tk 50".replaceAll("Tk", Matcher.quoteReplacement("$")) দেয় $ 50. আর যদি regex-এর দরকারই না থাকে — হুবহু একটি লেখা বদলাতে চান — তাহলে replace ব্যবহার করুন; সেটি দুটি argument-কেই হুবহু অর্থে নেয়।

split — regex দিয়ে কাটা, আর ফাঁকা টুকরোর নিয়ম

split-এর argument-ও regex, তাই একসাথে কয়েক রকম বিভাজক সামলানো যায়: "01711-111111, 01811 222222 ; 01911333333".split("\\s*[,;]\\s*") — “কমা বা সেমিকোলন, দুপাশে যত খুশি ফাঁকা” — দেয় তিনটি পরিষ্কার টুকরো। ফাঁকা টুকরো নিয়ে নিয়মটি অবশ্য মনে রাখতে হয় (সব যাচাই করা):

৭ · বাংলা, Unicode আর flag — \w কেন বাংলা চেনে না

এই অংশটি বাংলাভাষী প্রোগ্রামারদের জন্য বিশেষ গুরুত্বপূর্ণ। Java-র \w, \d, \b ডিফল্টে শুধু ASCII — অর্থাৎ ইংরেজি অক্ষর, ০–৯ অঙ্ক আর _. OpenJDK 21-এ যাচাই করা ফল:

অর্থাৎ ফাঁকা (\s) বাংলা লেখাতেও কাজ করে, কিন্তু “শব্দ”, “অঙ্ক” আর “শব্দের সীমা” ডিফল্টে বাংলাকে চেনে না। সমাধান Pattern.UNICODE_CHARACTER_CLASS flag (Java 7 থেকে), বা নকশার শুরুতে (?U). তখন \w Unicode-এর অক্ষর, কার-চিহ্ন, অঙ্ক সবই ধরে।

\p{…} — Unicode-এর নিজস্ব শ্রেণি

Unicode প্রতিটি code point-কে একটি শ্রেণি আর একটি লিপি দেয়। Regex-এ এগুলো ধরা যায় Unicode property দিয়ে: \p{L} যেকোনো লিপির অক্ষর (Letter), \p{M} চিহ্ন (Mark — কার, হসন্ত, অনুস্বার), \p{Nd} দশমিক অঙ্ক, \p{IsBengali} বাংলা লিপি। এখানেই বাংলার আসল জটিলতা চোখে পড়ে (যাচাই করা):

• "বাংলা".matches("\\p{L}+") → false! কারণ “া” আর “ং” Unicode-এ Letter নয়, Mark. চোখে যা অক্ষর, Unicode-এর হিসাবে তা অক্ষর আর চিহ্নের জোড়া।
• "বাংলা".matches("[\\p{L}\\p{M}]+") → true. বাংলা শব্দ ধরতে অক্ষর আর চিহ্ন দুটোই লাগে।
• "বাংলা".matches("\\p{IsBengali}+") → true; কিন্তু দাঁড়ি “।” \p{IsBengali}-এ পড়ে না — এটি দেবনাগরী ব্লকের অক্ষর, যা বাংলা আর হিন্দি দুই লিপিই ব্যবহার করে।
• “র‍্যাব”-এর মতো শব্দে র-ফলা ঠিক দেখাতে অদৃশ্য একটি অক্ষর থাকে — zero-width joiner (U+200D). এমন শব্দ [\p{L}\p{M}]+ বা \p{IsBengali}+-এ মেলে না, কিন্তু UNICODE_CHARACTER_CLASS-সহ \w+-এ মেলে, কারণ Java-র Unicode \w-এ এই join control অক্ষরও ধরা আছে।

পর্ব ০৮-এ দেখেছিলেন length() চোখের অক্ষর গোনে না; regex-এও একই কথা — . একটি code point ধরে, একটি grapheme cluster নয়। তাই "ক্ষ".matches("...") true: ক, হসন্ত, ষ — তিনটি code point.

Flag — নকশার আচরণ বদলানো

একাধিক flag জোড়া যায় | দিয়ে: Pattern.compile(regex, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE). উদাহরণ: তিন লাইনের লেখা "rice 50\nOil 180\nsalt 40"-এ ^[a-z]+ শুধু MULTILINE দিয়ে পায় [rice, salt], flag ছাড়া শুধু [rice], আর দুটো flag একসাথে দিলে [rice, Oil, salt] (যাচাই করা)।

Flag-গুলোর মধ্যে COMMENTS সবচেয়ে কম ব্যবহৃত, অথচ সবচেয়ে উপকারী। Text block-এর সাথে মিলিয়ে লম্বা নকশাকে পড়ার মতো করা যায়:

static final Pattern BD_MOBILE = Pattern.compile("""
        ^(?:\\+?880|0)   # দেশের কোড +880/880, নয়তো শুরুর 0
        1[3-9]           # অপারেটর অংশ: 13 থেকে 19
        \\d{8}$          # বাকি ৮টি অঙ্ক
        """, Pattern.COMMENTS);
// +8801712345678 → true, 8801912345678 → true, 01512345678 → true
// 01212345678 → false, +88001712345678 → false

খেয়াল করুন, text block-এর ভেতরেও \\+ আর \\d — দুটি backslash. আর নকশার যুক্তিটিও খেয়াল করুন: আন্তর্জাতিক রূপে শুরুর ০ বাদ যায় (+880 1712…), তাই (?:\+?880|0) — “+880 অথবা 0”, তারপর 1[3-9]. অনেকে (এবং অনেক AI) লেখেন (\+?880)?01[3-9]\d{8}, যা “+8801712345678”-কে বাতিল করে দেয় — আমরা নিজেরাও প্রথম খসড়ায় এই ভুল করেছিলাম, আর পরীক্ষা চালিয়ে ধরেছি।

Lookahead আর lookbehind — দেখে, কিন্তু খায় না

Lookaround হলো এমন শর্ত, যা বর্তমান অবস্থান থেকে সামনে বা পেছনে তাকিয়ে কিছু আছে কি না দেখে, কিন্তু কোনো অক্ষর খায় না। (?=…) সামনে আছে, (?!…) সামনে নেই, (?<=…) পেছনে আছে, (?<!…) পেছনে নেই। যেমন (?<=Tk )\d+ “Tk 500 for 3 items”-এ শুধু 500 পায়, 3 নয়।

পাসওয়ার্ড নীতি এর ক্লাসিক ব্যবহার: “অন্তত ৮ অক্ষর, একটি বড় হাতের, একটি ছোট হাতের, একটি অঙ্ক, একটি বিশেষ চিহ্ন।” প্রতিটি শর্ত একটি lookahead, সবগুলো লেখার শুরুতে দাঁড়িয়ে পুরো লেখায় চোখ বোলায়:

Pattern PASSWORD = Pattern.compile(
    "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[^A-Za-z0-9]).{8,}$");
// "Dhaka@2026" → true    "dhaka2026" → false (বড় হাতের ও চিহ্ন নেই)
// "Dhaka2026"  → false   "Dk@1"      → false (৮ অক্ষরের কম)

একই কৌশলে কার্ড বা NID নম্বর ঢাকা যায়: \d(?=(?:\D*\d){4}) মানে “এমন অঙ্ক, যার পরে আরও অন্তত চারটি অঙ্ক বাকি”। সেগুলোকে * দিয়ে বদলালে শুধু শেষ চারটি দেখা যায়, আর হাইফেন অক্ষত থাকে। নিচের প্রোগ্রামে এটি আর বাংলার ফলগুলো একসাথে চালিয়ে দেখুন, সাথে একটি এলোমেলো ফোন-তালিকা পরিষ্কার করা:

import java.util.Arrays;
import java.util.regex.Pattern;

class Main {
    static final Pattern BD_MOBILE = Pattern.compile("(?:\\+?880|0)1[3-9]\\d{8}");

    public static void main(String[] args) {
        String raw = "01712-345678, +880 1812 345678 ; 01212345678,,8801912345678, 0171234";
        String[] parts = raw.split("\\s*[,;]\\s*");
        System.out.println(parts.length + " parts: " + Arrays.toString(parts));
        for (String p : parts) {
            String clean = p.replaceAll("[\\s-]", "");
            String verdict = BD_MOBILE.matcher(clean).matches() ? "OK " : "BAD";
            System.out.println(verdict + " [" + clean + "]");
        }
        Pattern uniWord = Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS);
        System.out.println("\\w+ : " + "বাংলা".matches("\\w+") + " / UNICODE: " + uniWord.matcher("বাংলা").matches());
        System.out.println("\\p{L}+ : " + "বাংলা".matches("\\p{L}+") + " / [\\p{L}\\p{M}]+ : " + "বাংলা".matches("[\\p{L}\\p{M}]+"));
        System.out.println("card : " + "4111-2222-3333-4444".replaceAll("\\d(?=(?:\\D*\\d){4})", "*"));
    }
}

ইমেইল — একটি সৎ সতর্কতা

একটি সাধারণ ইমেইল যাচাই: ^[\w.+-]+@[\w-]+(\.[\w-]+)+$. এটি rahim.uddin@gmail.com আর info@abc.com.bd মেনে নেয়; rahim@gmail, a@b..com, rahim@@x.com বাতিল করে। কিন্তু .rahim@x.com-এর মতো নিয়মবিরুদ্ধ ঠিকানাও মেনে নেয়, আর বাংলা অক্ষরের ঠিকানা (যা আন্তর্জাতিক ইমেইলে সম্ভব) বাতিল করে (সব যাচাই করা)। ইমেইলের পূর্ণ নিয়ম (RFC 5322) এত জটিল যে একে পুরোপুরি ধরা regex কয়েক হাজার অক্ষরের হয়। বাস্তব পরামর্শ: regex দিয়ে শুধু “দেখতে মোটামুটি ইমেইলের মতো” কি না দেখুন, আর আসল যাচাই করুন একটি নিশ্চিতকরণ ইমেইল পাঠিয়ে।

৮ · গতি, নিরাপত্তা আর কখন regex নয়

একবার compile, বহুবার ব্যবহার

"…".matches(regex), replaceAll বা split প্রতিবার ডাকলে ভেতরে নকশাটি নতুন করে compile হয় (এক অক্ষরের সাধারণ বিভাজকে split-এর একটি দ্রুত পথ আছে, সেটি ব্যতিক্রম)। একটি লুপে লাখ লাইনের ওপর এমন ডাকলে লাখবার compile. সমাধান সহজ: নকশাটিকে একটি static final constant বানান, যেমন এই পর্বের BD_MOBILE বা AMOUNT. Pattern immutable আর thread-safe, তাই পুরো প্রোগ্রাম একটি object ভাগ করে নিতে পারে; প্রতিটি লেখার জন্য শুধু নতুন Matcher তৈরি হয়, যা হালকা। static আর final-এর পূর্ণ অর্থ দেখবেন পর্ব ১৮-এ।

Catastrophic backtracking — যখন একটি regex সার্ভার আটকে দেয়

অংশ ৪-এ দেখেছেন, মিল না পেলে engine পিছিয়ে এসে অন্য ভাগে চেষ্টা করে। সাধারণ নকশায় এই বিকল্প অল্প। কিন্তু একটি quantifier-এর ভেতরে আরেকটি quantifier থাকলে — যেমন (a+)+ — একই লেখাকে ভাগ করার উপায় বিস্ফোরকভাবে বাড়ে। আর মিল না থাকলে, engine প্রতিটি ভাগ চেষ্টা না করে “না” বলতে পারে না। একে বলে catastrophic backtracking. নিচে শুধু গুনে দেখুন (ধারণাগত হিসাব, কোনো সময় মাপা নয়):

1নকশা : (a+)+b2লেখা : a × n  (শেষে কোনো b নেই)3নিরাপদ: a+b

প্রতিরক্ষার বাস্তব চেকলিস্ট: (১) ব্যবহারকারীর লেখা দিয়ে কখনো সরাসরি নকশা বানাবেন না — Pattern.quote; (২) regex চালানোর আগে লেখার দৈর্ঘ্য সীমিত করুন (মোবাইল নম্বরের ঘরে ১০০০ অক্ষর আসার কারণ নেই); (৩) নেস্টেড quantifier আর ওভারল্যাপ করা বিকল্প খুঁজে দেখুন; (৪) শুধু মিলে এমন লেখা নয়, প্রায় মেলে কিন্তু শেষে ব্যর্থ হয় এমন লম্বা লেখা দিয়েও পরীক্ষা করুন — বিস্ফোরণ ঘটে ব্যর্থ হওয়ার পথেই।

কখন regex নয়

Regex লেখার আকৃতি চেনে, গঠন নয়। গণিতের ভাষায়, regular expression শুধু “regular language” চিনতে পারে, আর এমন ভাষা ইচ্ছামতো গভীর নেস্টিং গুনতে পারে না। HTML, JSON, XML, প্রোগ্রামিং ভাষা — সবখানেই ট্যাগ বা বন্ধনীর ভেতরে ট্যাগ-বন্ধনী থাকে। যেমন <b>(.*?)</b> “<b>Dhaka <b>Old</b> town</b>”-এ পায় Dhaka <b>Old — ভুল টুকরো (যাচাই করা)। এসব কাজে একটি parser ব্যবহার করুন: JSON-এর জন্য Jackson বা Gson (পর্ব ৩৯), HTML-এর জন্য jsoup-এর মতো library, CSV-র জন্য একটি CSV library. তারিখ পড়তে regex নয়, java.time-এর formatter (পর্ব ৩৮)।

৯ · AI-এর যুগে — AI-এর লেখা regex যাচাই

Regex এমন একটি কাজ, যা AI খুব দ্রুত করে দেয় — আর যা দেখতে প্রায় সবসময় ঠিক লাগে। সমস্যা হলো regex-এর ভুল চোখে পড়ে না; সেটি ধরা পড়ে একটি নির্দিষ্ট ইনপুটে, প্রায়ই প্রোডাকশনে। AI-এর লেখা regex-কে তাই সন্দেহের চোখে দেখুন, আর পরীক্ষার লেখা দিয়ে প্রমাণ চান।

AI সাধারণত যে ভুলগুলো করে

AI-এর regex হাতে পেলে — যাচাইয়ের চেকলিস্ট

• নকশার প্রতিটি অংশ আমি নিজের ভাষায় পড়তে পারি — “০, তারপর ১, তারপর…”
• যাচাইয়ের জন্য matches() (বা ^…$) ব্যবহার হয়েছে, find() নয়
• মেলা উচিত আর মেলা উচিত নয় — দুই তালিকা নিজে চালিয়েছি, শুধু AI-এর কথায় বিশ্বাস করিনি
• বাংলা লেখা বা অঙ্ক আসতে পারলে \w/\d-এর আচরণ পরীক্ষা করেছি
• নেস্টেড quantifier নেই, আর লম্বা ব্যর্থ ইনপুট (যেমন ৫০টি অক্ষর + একটি ভুল অক্ষর) দিয়ে গতি দেখেছি
• নকশা static final Pattern, আর বাইরের লেখা নকশায় গেলে Pattern.quote