regular expression — খোঁজা, যাচাই আর বদলানো

১ · regular expression কী — লেখার “আকৃতি” বর্ণনার ছোট একটি ভাষা

একটি ফর্মে মোবাইল নম্বর নেওয়া হচ্ছে। নম্বরটি ঠিক আছে কি না যাচাই করতে চান। নিয়মটা মুখে বললে সহজ: “শুরুতে 0 আর 1, তারপর 3 থেকে 9-এর একটি অঙ্ক, তারপর ঠিক আটটি অঙ্ক — ব্যস, এর বেশি কিছু নয়।” কিন্তু সাধারণ JavaScript-এ লিখতে গেলে লাগে দৈর্ঘ্য যাচাই, একটি লুপ, প্রতিটি অক্ষর অঙ্ক কি না দেখা, তৃতীয় অক্ষরের আলাদা শর্ত — দশ-বারো লাইন, আর প্রতিটি লাইনে ভুলের সুযোগ।

Regular expression (সংক্ষেপে regex বা regexp) এই মুখের কথাটিকেই সরাসরি লেখার একটি ছোট ভাষা। উপরের নিয়মটি regex-এ:

/^01[3-9]\d{8}$/
 │ │ │    │   └─ $   : লেখা এখানেই শেষ
 │ │ │    └───── \d{8}: ঠিক ৮টি অঙ্ক
 │ │ └────────── [3-9]: 3 থেকে 9-এর যেকোনো একটি
 │ └──────────── 01   : হুবহু 0, তারপর 1
 └────────────── ^    : লেখার একেবারে শুরু

কখন regex, কখন নয়

Regex শক্তিশালী, কিন্তু এর দুটি দাম আছে: পড়তে কঠিন (এক লাইনে অনেক চিহ্ন), আর খারাপভাবে লিখলে ধীর — এমনকি এত ধীর যে সার্ভার আটকে যায় (অংশ ৮)। তাই নিয়ম হলো: নকশা ছোট রাখুন, প্রতিটি নকশা পরীক্ষার ডেটা দিয়ে যাচাই করুন, আর সহজ string method দিয়ে কাজ হলে সেটাই ব্যবহার করুন।

২ · regex বানানোর দুই উপায় — /…/flags, new RegExp আর escaping

JavaScript-এ regex একটি object — RegExp class-এর instance. বানানোর দুই উপায়:

// ১) literal — নকশা আগে থেকেই জানা থাকলে (সবচেয়ে প্রচলিত)
const phone = /^01[3-9]\d{8}$/;
const word  = /dhaka/gi;          // শেষে flag: g আর i

// ২) constructor — নকশা চলার সময় তৈরি হলে
const city  = "Dhaka";
const re    = new RegExp(city, "gi");       // /Dhaka/gi
const digits = new RegExp("\\d+");          // string-এ backslash দুবার!
const same   = new RegExp(String.raw`\d+`); // অথবা String.raw

বিশেষ অক্ষর আর escaping

নকশার কিছু অক্ষরের বিশেষ মানে আছে — এদের বলে metacharacter: . * + ? ^ $ { } ( ) [ ] | \ /. এদের হুবহু অক্ষর হিসেবে খুঁজতে আগে backslash দিন: দাম “৳1.50” খুঁজতে /1\.50/; শুধু /1.50/ লিখলে . মানে “যেকোনো একটি অক্ষর”, তাই “1x50”-ও মিলে যাবে।

ব্যবহারকারীর লেখা দিয়ে regex — আগে escape

একটি সার্চ বক্সে ব্যবহারকারী লিখলেন C++ (basic), আর আপনি সেটি দিয়ে সরাসরি new RegExp(input) বানালেন। ফল: SyntaxError: Invalid regular expression: /C++ (basic)/: Nothing to repeat (V8-এর বার্তা) — কারণ + আর ( ) নকশার চিহ্ন। আরও খারাপ: কেউ ইচ্ছা করে (a+)+$-এর মতো লেখা দিলে আপনার নিজের সার্ভার ধীর হয়ে যেতে পারে (অংশ ৮)। নিয়ম: বাইরের লেখা regex-এ বসানোর আগে সব বিশেষ অক্ষর escape করুন, যাতে সেগুলো হুবহু অক্ষর হিসেবে খোঁজা হয়।

// সব জায়গায় চলে এমন ছোট escape function
const escapeRegex = s => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
escapeRegex("C++ (basic)");   // "C\+\+ \(basic\)"

// ES2025-এর built-in (নতুন ব্রাউজারে)
RegExp.escape("C++ (basic)");  // প্রতিটি বিশেষ অক্ষর নিরাপদে escape করে

আটটি flag — পুরো নকশার আচরণ বদলানোর সুইচ

Flag লেখা হয় literal-এর শেষ /-এর পরে, বা constructor-এর দ্বিতীয় argument হিসেবে। re.flags পড়লে সবগুলো একসাথে পাওয়া যায়।

দুটি তথ্য মনে রাখুন। এক, u আর v একসাথে দেওয়া যায় না — v নিজেই u-এর সব সুবিধা দেয়। দুই, v flag Chrome/Edge ১১২ (২০২৩) থেকে আছে, আর Node.js 20-এও চলে; খুব পুরোনো ব্রাউজার সমর্থন করতে হলে u-ই নিরাপদ।

৩ · নকশার ইট — character class, anchor আর quantifier

যেকোনো regex মাত্র কয়েক রকম ইট দিয়ে তৈরি। প্রথম ইট হলো হুবহু অক্ষর: /bKash/ শুধু “bKash” মেলায়। দ্বিতীয় ইট character class — একটি ঘরের জন্য কয়েকটি বিকল্প।

তৃতীয় ইট anchor — যা কোনো অক্ষর খায় না, শুধু একটি অবস্থান দাবি করে। ^ = লেখার শুরু, $ = লেখার শেষ (m flag দিলে প্রতিটি লাইনের)। \b হলো word boundary — যেখানে একদিকে \w আর অন্যদিকে নয়। /\bcat\b/ “cat” শব্দ পায়, কিন্তু “category”-র ভেতরের cat নয়। যেহেতু \w শুধু ইংরেজি চেনে, \b-ও বাংলায় অকেজো — অংশ ৭-এ দেখবেন /\bআম\b/.test("আম") পর্যন্ত false!

চতুর্থ ইট quantifier — ঠিক আগের জিনিসটি কতবার আসবে:

Quantifier শুধু তার ঠিক আগের একটি জিনিসের ওপর খাটে: /ab+/ মানে “a, তারপর এক বা একাধিক b”. পুরো “ab” বারবার চাইলে বন্ধনী: /(ab)+/. এবার দেখুন engine এই ইটগুলো দিয়ে আসলে কীভাবে হাঁটে। “পরে” চাপুন:

10        হুবহু '0'21        হুবহু '1'3[3-9]    3 থেকে 9-এর একটি4\d{8}    ঠিক ৮টি অঙ্ক5(শেষ)    নকশা পুরো মিলেছে

৪ · greedy বনাম lazy — quantifier কতটুকু খাবে, আর backtracking

.+ মানে “এক বা একাধিক যেকোনো অক্ষর”। কিন্তু ঠিক কতগুলো? JavaScript-এর quantifier ডিফল্টে greedy: প্রথমে যত বেশি সম্ভব খায়, তারপর বাকি নকশা না মিললে একটি একটি করে ফেরত দেয়। Quantifier-এর পরে ? দিলে (+?, *?, ??, {n,m}?) সেটি হয় lazy: যত কম সম্ভব খায়, দরকার হলে একটি একটি করে বাড়ায়। এই “ফেরত দিয়ে আবার চেষ্টা”-র নাম backtracking.

1s.match(/<.+>/)       // greedy2s.match(/<.+?>/g)     // lazy3s.match(/<[^>]+>/g)  // যা চাই না, তা বাদ

Backtracking কাছ থেকে — একটি সহজ নকশা

Backtracking শুধু greedy-lazy-এর ব্যাপার নয়; এটি JavaScript-এর regex engine-এর কাজ করার মূল কৌশল। একটি বাস্তব উদাহরণ: “12500” লেখাকে হাজারের আগের অংশ আর শেষ তিন অঙ্কে ভাগ করা — /^(\d+)(\d{3})$/.

৫ · group, backreference, alternation আর lookaround

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

Lookaround — দেখে নেয়, কিন্তু খায় না

কখনো শর্ত দরকার, কিন্তু সেই অংশটি মিলের ভেতরে চান না। “টাকা” শব্দের ঠিক আগের সংখ্যাটি চাই, “টাকা” নয়। এর জন্য lookahead আর lookbehind — anchor-এর মতোই এরা কোনো অক্ষর খায় না, শুধু পাশের লেখা পরীক্ষা করে।

একটি ক্লাসিক কৌশল: "1234567".replace(/\B(?=(\d{3})+(?!\d))/g, ",") দেয় 1,234,567 — “যেখানে ডানে তিনের গুণিতক সংখ্যক অঙ্ক বাকি, সেখানে কমা”। তবে বাংলাদেশে লাখ-কোটির নিয়মে কমা বসে (১২,৩৪,৫৬৭), আর এমন কাজে regex-এর চেয়ে Intl.NumberFormat("bn-BD") অনেক নির্ভরযোগ্য (পর্ব ২০)। JavaScript-এর lookbehind যেকোনো দৈর্ঘ্যের নকশা নিতে পারে — Python-এর মতো স্থির দৈর্ঘ্যের বা Java-র মতো সীমিত দৈর্ঘ্যের বাধ্যবাধকতা নেই।

৬ · regex-এর method — test, exec, match, matchAll, replace, split

কিছু method থাকে regex-এর ওপর (re.test(s)), কিছু string-এর ওপর (s.match(re)). কোনটি কী ফেরত দেয়, সেটিই আসল কথা:

matchAll-এ g না দিলে Node.js আর Chrome/Edge-এ বার্তা আসে TypeError: String.prototype.matchAll called with a non-global RegExp argument; replaceAll-এ একই বার্তা, শুধু method-এর নামটি আলাদা। এই নিয়ম ইচ্ছাকৃত: “সব মিল” চাওয়ার সময় ভুলে “একটি মিল”-এর regex দিলে চুপচাপ ভুল ফলের বদলে স্পষ্ট error পাওয়া ভালো।

lastIndex-এর ফাঁদ — g flag মানে regex-এর ভেতরে স্মৃতি

g বা y flag-যুক্ত regex একটি সংখ্যা মনে রাখে — lastIndex: পরের খোঁজা কোন ঘর থেকে শুরু হবে। exec দিয়ে লুপে সব মিল বের করতে এটি দরকারি। কিন্তু একই regex দিয়ে বারবার test() ডাকলে এই স্মৃতিই বাগ হয়ে দাঁড়ায়:

1const re = /01[3-9]\d{8}/g;2re.test("01712345678");3re.test("01712345678");4re.test("01712345678");5// সমাধান: g বাদ, অথবা re.lastIndex = 0

এবার সব একসাথে চালিয়ে দেখুন — ফোন-তালিকা যাচাই, anchor ভুলে যাওয়ার বিপদ, lastIndex-এর ফাঁদ আর SMS থেকে অর্ডার নম্বর তোলা:

// ১) বাংলাদেশি মোবাইল নম্বর — শুরু থেকে শেষ পর্যন্ত মিলতে হবে
const BD_MOBILE = /^(?:\+?880|0)1[3-9]\d{8}$/;
const list = ["01712345678", "+8801812345678", "01212345678",
  "0171234567", "আমার নম্বর 01712345678", "01712345678 "];
for (const p of list) console.log(BD_MOBILE.test(p) ? "✓" : "✗", JSON.stringify(p));

// ২) anchor ছাড়া: লেখার ভেতরে কোথাও মিললেই true
console.log(/01[3-9]\d{8}/.test("নম্বর: 0171234567890"));

// ৩) g flag-এর ফাঁদ: একই regex, একই লেখা, দুবার test()
const once = /01[3-9]\d{8}/g;
console.log(once.test("01712345678"), once.lastIndex, once.test("01712345678"), once.lastIndex);

// ৪) SMS থেকে সব অর্ডার নম্বর — matchAll-এ g লাগবেই
const sms = "ORD-1042 পাঠানো হয়েছে, ORD-1043 প্রস্তুত, ORD-99 বাতিল";
for (const m of sms.matchAll(/ORD-(\d{4})\b/g)) console.log(m[1], "index", m.index);

replace-এর বদলি লেখা আর function

replace-এর দ্বিতীয় argument string হলে তার ভেতরে কয়েকটি বিশেষ সংকেত কাজ করে: $1, $2 = group, $<name> = named group, $& = পুরো মিল, $$ = একটি আসল $ চিহ্ন। যেমন "15/03/2026".replace(/(\d{2})\/(\d{2})\/(\d{4})/, "$3-$2-$1") দেয় 2026-03-15.

দ্বিতীয় argument একটি function হলে প্রতিটি মিলের জন্য সেটি ডাকা হয়, আর যা ফেরত দেয় সেটিই বসে। Function পায় (match, p1, p2, …, offset, string, groups) — পুরো মিল, প্রতিটি group, মিলের অবস্থান, পুরো লেখা আর named group-এর object. হিসাব করে বদলাতে (দাম দ্বিগুণ, অঙ্ক রূপান্তর, বড় হাতের অক্ষর) এটিই পথ — পরের অংশের কোডে দেখবেন।

split-এ regex দিলে একাধিক বিভাজক একসাথে সামলানো যায়: "a, b;c".split(/[,;]\s*/) দেয় ["a", "b", "c"]. নকশায় capturing group থাকলে বিভাজকও ফলে ঢোকে: "a1b".split(/(\d)/) → ["a", "1", "b"].

৭ · বাংলা লেখায় regex — u flag, \p{…} আর বাংলা অঙ্ক

JavaScript-এর regex-এর জন্ম ১৯৯০-এর দশকে, ইংরেজি-কেন্দ্রিক Perl-এর আদলে। তাই পুরোনো সংক্ষিপ্ত রূপগুলো শুধু ইংরেজি চেনে, আর এ নিয়ম u flag দিলেও বদলায় না — পুরোনো কোড যাতে না ভাঙে:

• \w = [A-Za-z0-9_]. বাংলা অক্ষর এর বাইরে, তাই /\w+/.exec("বাংলা") দেয় null.
• \b নির্ভর করে \w-এর ওপর। “আম” লেখায় কোনো \w নেই, তাই কোনো সীমানাও নেই: /\bআম\b/.test("আম") হলো false — আমরা Node.js আর Edge-এ যাচাই করেছি।
• \d = শুধু 0–9. /\d/.test("৫") হলো false. বাংলা অঙ্কের জন্য লিখুন [০-৯] — ০ থেকে ৯ Unicode-এ পরপর সাজানো (U+09E6–U+09EF), তাই পরিসর কাজ করে।

Unicode property escape — অক্ষরকে তার বৈশিষ্ট্য দিয়ে চেনা

ES2018 থেকে u (বা v) flag দিলে Unicode property escape লেখা যায়: \p{…} মানে “এই বৈশিষ্ট্যের যেকোনো একটি অক্ষর”, \P{…} উল্টো। প্রতিটি code point-এর সাথে Unicode কিছু তথ্য রাখে — কোন লিপির, অক্ষর না চিহ্ন না অঙ্ক — আর \p সেই তথ্য দিয়ে খোঁজে।

u flag ভুলে গেলে কী হয়? /\p{L}/ লিখলে \p হয়ে যায় সাধারণ “p” অক্ষর, আর নকশাটি খোঁজে আক্ষরিক লেখা “p{L}”! কোনো error আসে না — /\p{L}/.test("p{L}") হলো true. এজন্যই নিয়ম: বাংলা বা ইমোজি থাকতে পারে এমন লেখায় সবসময় u বা v flag. u আরেকটি কাজও করে: . তখন একটি পুরো code point ধরে, তাই /^.$/u.test("🙂") হলো true, কিন্তু u ছাড়া false — কারণ পর্ব ০৯-এ দেখা surrogate pair-এর দুটি ঘর।

এবার বাস্তব কাজ — বাংলা অঙ্ক রূপান্তর, তারিখের format বদলানো, নম্বর ঢাকা আর বাংলা শব্দ গোনা:

// ১) বাংলা অঙ্ক → ইংরেজি অঙ্ক: বদলি হিসেবে একটি function
const BN = "০১২৩৪৫৬৭৮৯";
const toLatin = s => s.replace(/[০-৯]/g, d => BN.indexOf(d));
console.log(toLatin("০১৭১২৩৪৫৬৭৮"), /\d/.test("৫"));

// ২) named group দিয়ে তারিখ ঘোরানো: 15/03/2026 → 2026-03-15
const DATE = /^(?<d>\d{2})\/(?<m>\d{2})\/(?<y>\d{4})$/;
console.log("15/03/2026".replace(DATE, "$<y>-$<m>-$<d>"));

// ৩) নম্বর ঢাকা: প্রথম ৩টি আর শেষ ৩টি অঙ্ক রেখে
console.log("01712345123".replace(/^(\d{3})\d{5}(\d{3})$/, "$1XXXXX$2"));

// ৪) বাংলা শব্দ: \w ব্যর্থ, \p{L} অর্ধেক, Script=Bengali সফল
const text = "আমি ঢাকায় থাকি। I love Dhaka, মেট্রোরেল চমৎকার!";
console.log(text.match(/\w+/g));
console.log("ঢাকায় থাকি".match(/\p{L}+/gu));
const words = text.match(/\p{Script=Bengali}+/gu);
console.log(words.length, words);

বাংলায় word boundary বানানো

\b অকেজো হলে lookaround দিয়ে নিজের সীমানা বানান: /(?<![\p{L}\p{M}])আম(?![\p{L}\p{M}])/u মানে “আম, যার আগে বা পরে কোনো অক্ষর বা কার-চিহ্ন নেই”। এটি “আম খাই”-তে মেলে, কিন্তু “আমার” বা “জাম”-এ নয় (যাচাই করা)। এই ধরনের নকশা হুবহু মুখস্থ রাখার দরকার নেই — মনে রাখুন, বাংলায় \b লেখা দেখলেই সন্দেহ করুন।

v flag — class-এর ভেতরে অঙ্ক কষা

ES2024-এর v flag (unicodeSets) character class-এ set-এর হিসাব আনে: -- বিয়োগ আর && ছেদ। /[\p{Script=Bengali}&&\p{Nd}]/v = “বাংলা লিপির দশমিক অঙ্ক” — ৫ মেলে, ক মেলে না। /[\p{L}--\p{Script=Latin}]/v = “ইংরেজি ছাড়া যেকোনো অক্ষর”। v দিয়ে \p{RGI_Emoji}-এর মতো “লেখার property”-ও খোঁজা যায়, যা একাধিক code point-এর পুরো ইমোজি (যেমন 👍🏽) একসাথে ধরে।

৮ · বাস্তব যাচাই, ReDoS আর পড়ার মতো regex

বাংলাদেশি তথ্যের format যাচাই

নিচের নকশাগুলো শুধু format যাচাই করে — “দেখতে ঠিক আছে কি না”। নম্বরটি সত্যিই কারও কি না, NID আসল কি না, ঠিকানা আছে কি না — regex তা জানে না, জানার উপায়ও নেই। আসল যাচাই হয় OTP, confirmation ইমেইল বা সংশ্লিষ্ট কর্তৃপক্ষের সেবা দিয়ে।

ইমেইলের জন্য ছোট নকশা কেন? ইমেইল ঠিকানার আনুষ্ঠানিক নিয়ম (RFC 5322) এত জটিল যে তাকে পুরোপুরি ধরা regex কয়েকশো অক্ষরের হয় — পড়া অসম্ভব, আর তবুও বলতে পারে না ঠিকানাটি কাজ করে কি না। ব্রাউজারে সহজ পথ <input type="email">: এটি নিজেই একটি যুক্তিসঙ্গত format যাচাই করে (পর্ব ৩৯)। তারপর একটি confirmation লিংক পাঠান — সেটিই একমাত্র আসল যাচাই।

Catastrophic backtracking আর ReDoS

অংশ ৪-এ দেখেছেন, “12500”-এ engine মাত্র তিনবার পিছিয়েছিল। এবার /^(a+)+$/ নকশাটি ভাবুন, আর লেখা “aaaaaaaaaaaaaaaaaaaaX” — অনেকগুলো a, শেষে একটি X, তাই মিল কখনোই হবে না। কিন্তু “মিল নেই” বলার আগে engine-কে প্রমাণ করতে হয় যে কোনো উপায়েই মেলে না। আর বাইরের + আর ভেতরের + মিলে n-টি a-কে ভাগ করার উপায় 2ⁿ⁻¹টি: “aaaa” হতে পারে (aaaa), (aaa)(a), (aa)(aa), (a)(aaa), (a)(a)(aa)… engine সবগুলো চেষ্টা করে। একে বলে catastrophic backtracking.

প্রতিটি a যোগ করলে কাজ দ্বিগুণ। ব্রাউজারে এর মানে পাতা জমে যাওয়া, কারণ regex চলে main thread-এ (পর্ব ৩১-এ event loop দেখবেন)। আর Node.js সার্ভারে এর মানে আরও খারাপ: একটিমাত্র অনুরোধ পুরো প্রসেস আটকে দেয়, অন্য সব ব্যবহারকারী অপেক্ষায় থাকেন। কেউ ইচ্ছা করে এমন ইনপুট পাঠালে তার নাম ReDoS (Regular expression Denial of Service). আত্মরক্ষার উপায়:

• নেস্টেড quantifier এড়ান: (a+)+, (\w+\s?)*, (.*)*-এর মতো নকশা — যেখানে একই লেখা একাধিক উপায়ে ভাগ হতে পারে — সবচেয়ে বিপজ্জনক। (a+)+-এর বদলে শুধু a+.
• Alternation-এর বিকল্পগুলো যেন একে অপরকে না ঢাকে: (\d|\d\d)+-এর মতো ওভারল্যাপ একই বিস্ফোরণ ঘটায়।
• ইনপুটের দৈর্ঘ্য আগে সীমিত করুন: ফোন নম্বরের ঘরে ২০ অক্ষরের বেশি এলে regex চালানোর আগেই বাতিল।
• বাইরের লেখা regex-এ বসালে escape করুন (অংশ ২) — ব্যবহারকারী যেন নিজের নকশা চালাতে না পারেন।
• সার্ভারে বাইরের নকশা চালাতেই হলে linear-time engine: Google-এর RE2-এর মতো engine backtracking করে না, তাই সময় ইনপুটের দৈর্ঘ্যের সমানুপাতিক থাকে (বিনিময়ে backreference আর lookaround ছাড়তে হয়)। Node.js-এ এর binding প্যাকেজ আকারে পাওয়া যায়।

পড়ার মতো regex — টুকরো দিয়ে গড়ুন, মন্তব্য লিখুন, পরীক্ষা রাখুন

Python বা Java-র regex-এ মন্তব্যসহ বহু-লাইনের “verbose” মোড আছে; JavaScript-এ নেই। তবে String.raw আর array-এর join দিয়ে একই সুবিধা পাওয়া যায় — প্রতিটি টুকরো আলাদা লাইনে, পাশে মন্তব্য:

const BD_MOBILE = new RegExp([
  "^",
  String.raw`(?:\+?880|0)`,  // দেশের কোড +880/880, অথবা শুরুর 0
  String.raw`1[3-9]`,        // অপারেটর কোড: 013–019
  String.raw`\d{8}`,         // বাকি ৮টি অঙ্ক
  "$",
].join(""));

// নকশার পাশেই পরীক্ষার তালিকা — নকশা বদলালে আবার চালান
const cases = [["01712345678", true], ["+8801312345678", true],
               ["01212345678", false], ["017123456789", false]];
for (const [input, want] of cases)
  console.assert(BD_MOBILE.test(input) === want, input);

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

Regex এমন একটি জায়গা, যেখানে AI-এর উত্তর দেখতে সবচেয়ে বিশ্বাসযোগ্য আর যাচাই করা সবচেয়ে কঠিন। এক লাইনের চিহ্নের স্তূপ পড়ে কেউ বলতে পারে না সেটি ঠিক কি না — চালিয়ে দেখতে হয়। AI যে কোড থেকে শিখেছে তার বেশিরভাগ ইংরেজি লেখা নিয়ে, তাই কয়েকটি ভুল বারবার ফিরে আসে:

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

• যাচাইয়ের নকশায় ^ আর $ আছে, আর g flag নেই
• বৈধ, অবৈধ আর “প্রায় বৈধ” (এক অঙ্ক কম/বেশি, শেষে space, সামনে শব্দ) ইনপুট দিয়ে নিজে চালিয়েছি
• বাংলা ইনপুট থাকলে \w, \b, \d খুঁজে বদলেছি; \p{…} থাকলে u/v flag আছে
• নেস্টেড বা ওভারল্যাপ করা quantifier নেই; ইনপুটের দৈর্ঘ্যের সীমা আছে
• new RegExp-এ বাইরের লেখা গেলে সেটি escape করা হয়েছে
• নকশাটি regex101-এ বা পরীক্ষার তালিকায় টুকরো ধরে বুঝে নিয়েছি — না বুঝে কোডে বসাইনি