জাভাস্ক্রিপ্টের কোর অপটিমাইজেশন: একটি উচ্চ-ক্ষমতাসম্পন্ন স্ট্রিং প্যাটার্ন ম্যাচিং ইঞ্জিন তৈরি

সফ্টওয়্যার ডেভেলপমেন্টের বিশাল জগতে, স্ট্রিং প্রসেসিং একটি মৌলিক এবং সর্বব্যাপী কাজ। একটি টেক্সট এডিটরের সাধারণ 'ফাইন্ড অ্যান্ড রিপ্লেস' থেকে শুরু করে ক্ষতিকারক পেলোডের জন্য নেটওয়ার্ক ট্র্যাফিক স্ক্যান করা অত্যাধুনিক ইনট্রুশন ডিটেকশন সিস্টেম পর্যন্ত, টেক্সটের মধ্যে দক্ষতার সাথে প্যাটার্ন খুঁজে বের করার ক্ষমতা আধুনিক কম্পিউটিংয়ের একটি ভিত্তি। জাভাস্ক্রিপ্ট ডেভেলপারদের জন্য, যারা এমন একটি পরিবেশে কাজ করেন যেখানে পারফরম্যান্স সরাসরি ব্যবহারকারীর অভিজ্ঞতা এবং সার্ভার খরচকে প্রভাবিত করে, স্ট্রিং প্যাটার্ন ম্যাচিংয়ের সূক্ষ্মতা বোঝা শুধু একটি অ্যাকাডেমিক অনুশীলন নয়—এটি একটি অত্যন্ত গুরুত্বপূর্ণ পেশাগত দক্ষতা।

যদিও জাভাস্ক্রিপ্টের বিল্ট-ইন মেথড যেমন String.prototype.indexOf(), includes(), এবং শক্তিশালী RegExp ইঞ্জিন আমাদের দৈনন্দিন কাজে ভালোভাবে সাহায্য করে, উচ্চ-থ্রুপুট অ্যাপ্লিকেশনগুলিতে এগুলি পারফরম্যান্সের প্রতিবন্ধকতা সৃষ্টি করতে পারে। যখন আপনাকে একটি বিশাল ডকুমেন্টে হাজার হাজার কীওয়ার্ড অনুসন্ধান করতে হয়, বা লক্ষ লক্ষ লগ এন্ট্রিকে কিছু নিয়মের বিরুদ্ধে যাচাই করতে হয়, তখন সাধারণ পদ্ধতিটি আর কার্যকর থাকে না। এখানেই আমাদের স্ট্যান্ডার্ড লাইব্রেরির বাইরে, কম্পিউটার বিজ্ঞানের অ্যালগরিদম এবং ডেটা স্ট্রাকচারের জগতে আরও গভীরে যেতে হবে এবং আমাদের নিজস্ব অপটিমাইজড স্ট্রিং প্রসেসিং ইঞ্জিন তৈরি করতে হবে।

এই বিস্তারিত গাইড আপনাকে সাধারণ, ব্রুট-ফোর্স পদ্ধতি থেকে শুরু করে আহো-কোরাসিকের মতো উন্নত, উচ্চ-ক্ষমতাসম্পন্ন অ্যালগরিদম পর্যন্ত একটি যাত্রায় নিয়ে যাবে। আমরা বিশ্লেষণ করব কেন নির্দিষ্ট কিছু পদ্ধতি চাপের মধ্যে ব্যর্থ হয় এবং কীভাবে অন্যরা, চতুর প্রি-কম্পিউটেশন এবং স্টেট ম্যানেজমেন্টের মাধ্যমে, লিনিয়ার-টাইম দক্ষতা অর্জন করে। শেষে, আপনি কেবল তত্ত্বই বুঝবেন না, বরং স্ক্র্যাচ থেকে জাভাস্ক্রিপ্টে একটি বাস্তবসম্মত, উচ্চ-ক্ষমতাসম্পন্ন, মাল্টি-প্যাটার্ন ম্যাচিং ইঞ্জিন তৈরি করতে সক্ষম হবেন।

স্ট্রিং ম্যাচিং এর ব্যাপক প্রকৃতি

কোডে প্রবেশ করার আগে, দক্ষ স্ট্রিং ম্যাচিং-এর উপর নির্ভরশীল অ্যাপ্লিকেশনগুলির বিশাল পরিসর উপলব্ধি করা অপরিহার্য। এই ব্যবহারের ক্ষেত্রগুলি চেনা অপটিমাইজেশনের গুরুত্ব বুঝতে সাহায্য করে।

• ওয়েব অ্যাপ্লিকেশন ফায়ারওয়াল (WAFs): নিরাপত্তা ব্যবস্থা হাজার হাজার পরিচিত অ্যাটাক সিগনেচার (যেমন, SQL ইনজেকশন, ক্রস-সাইট স্ক্রিপ্টিং প্যাটার্ন) এর জন্য ইনকামিং HTTP রিকোয়েস্ট স্ক্যান করে। ব্যবহারকারীর অনুরোধে বিলম্ব এড়াতে এটি মাইক্রোসেকেন্ডের মধ্যে সম্পন্ন হতে হয়।
• টেক্সট এডিটর এবং IDEs: সিনট্যাক্স হাইলাইটিং, ইন্টেলিজেন্ট সার্চ এবং 'ফাইন্ড অল অকারেন্সেস' এর মতো বৈশিষ্ট্যগুলি সম্ভাব্য বড় সোর্স কোড ফাইলগুলিতে দ্রুত একাধিক কীওয়ার্ড এবং প্যাটার্ন সনাক্ত করার উপর নির্ভর করে।
• কনটেন্ট ফিল্টারিং এবং মডারেশন: সোশ্যাল মিডিয়া প্ল্যাটফর্ম এবং ফোরামগুলি ব্যবহারকারীদের দ্বারা তৈরি কন্টেন্ট রিয়েল-টাইমে অনুপযুক্ত শব্দ বা বাক্যাংশের একটি বড় অভিধানের সাথে মিলিয়ে স্ক্যান করে।
• বায়োইনফরমেটিক্স: বিজ্ঞানীরা বিশাল ডিএনএ স্ট্র্যান্ড (টেক্সট) এর মধ্যে নির্দিষ্ট জিন সিকোয়েন্স (প্যাটার্ন) অনুসন্ধান করেন। এই অ্যালগরিদমগুলির দক্ষতা জিনোমিক গবেষণার জন্য অত্যন্ত গুরুত্বপূর্ণ।
• ডেটা লস প্রিভেনশন (DLP) সিস্টেম: এই সরঞ্জামগুলি ডেটা লঙ্ঘন প্রতিরোধ করার জন্য ক্রেডিট কার্ড নম্বর বা অভ্যন্তরীণ প্রজেক্ট কোডনেমের মতো সংবেদনশীল তথ্যের প্যাটার্নের জন্য আউটগোয়িং ইমেল এবং ফাইল স্ক্যান করে।
• সার্চ ইঞ্জিন: তাদের মূলে, সার্চ ইঞ্জিনগুলি অত্যাধুনিক প্যাটার্ন ম্যাচিং সিস্টেম, যা ওয়েবকে ইন্ডেক্স করে এবং ব্যবহারকারীর জিজ্ঞাসা করা প্যাটার্ন ধারণকারী ডকুমেন্ট খুঁজে বের করে।

এই প্রতিটি ক্ষেত্রে, পারফরম্যান্স কোনো বিলাসিতা নয়; এটি একটি মূল প্রয়োজনীয়তা। একটি ধীরগতির অ্যালগরিদম নিরাপত্তা ঝুঁকি, দুর্বল ব্যবহারকারীর অভিজ্ঞতা বা সাধ্যাতীত কম্পিউটেশনাল খরচের কারণ হতে পারে।

সাধারণ পদ্ধতি এবং এর অনিবার্য সীমাবদ্ধতা

চলুন একটি টেক্সটে প্যাটার্ন খোঁজার সবচেয়ে সহজ উপায় দিয়ে শুরু করি: ব্রুট-ফোর্স পদ্ধতি। এর যুক্তিটি সহজ: প্যাটার্নটিকে টেক্সটের উপর একবারে একটি করে অক্ষর স্লাইড করুন এবং প্রতিটি অবস্থানে, প্যাটার্নটি সংশ্লিষ্ট টেক্সট অংশের সাথে মেলে কিনা তা পরীক্ষা করুন।

একটি ব্রুট-ফোর্স ইমপ্লিমেন্টেশন

ভাবুন আমরা একটি বড় টেক্সটের মধ্যে একটি নির্দিষ্ট প্যাটার্নের সমস্ত উপস্থিতি খুঁজে বের করতে চাই।

            
function naiveSearch(text, pattern) {
    const textLength = text.length;
    const patternLength = pattern.length;
    const occurrences = [];

    if (patternLength === 0) return [];

    for (let i = 0; i <= textLength - patternLength; i++) {
        let match = true;
        for (let j = 0; j < patternLength; j++) {
            if (text[i + j] !== pattern[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            occurrences.push(i);
        }
    }

    return occurrences;
}

const text = "abracadabra";
const pattern = "abra";
console.log(naiveSearch(text, pattern)); // Output: [0, 7]

            

              
                Copy
              
            
          

এটি কেন ব্যর্থ হয়: টাইম কমপ্লেক্সিটি বিশ্লেষণ

বাইরের লুপটি প্রায় N বার চলে (যেখানে N হল টেক্সটের দৈর্ঘ্য), এবং ভেতরের লুপটি M বার চলে (যেখানে M হল প্যাটার্নের দৈর্ঘ্য)। এটি অ্যালগরিদমটিকে O(N * M) এর একটি টাইম কমপ্লেক্সিটি দেয়। ছোট স্ট্রিংগুলির জন্য, এটি ঠিক আছে। কিন্তু একটি ১০MB টেক্সট (≈১,০০,০০,০০০ অক্ষর) এবং একটি ১০০-অক্ষরের প্যাটার্নের কথা ভাবুন। তুলনার সংখ্যা বিলিয়নে পৌঁছাতে পারে।

এখন, যদি আমাদের K সংখ্যক ভিন্ন প্যাটার্ন অনুসন্ধান করতে হয়? সাধারণ সমাধান হবে আমাদের প্যাটার্নগুলির উপর লুপ চালানো এবং প্রতিটির জন্য সাধারণ অনুসন্ধান চালানো, যা O(K * N * M) এর মতো একটি ভয়াবহ কমপ্লেক্সিটির দিকে নিয়ে যাবে। যেকোনো গুরুতর অ্যাপ্লিকেশনের জন্য এই পদ্ধতিটি সম্পূর্ণরূপে ভেঙে পড়ে।

ব্রুট-ফোর্স পদ্ধতির মূল অদক্ষতা হলো এটি অমিল থেকে কিছুই শেখে না। যখন একটি অমিল ঘটে, তখন এটি প্যাটার্নটিকে কেবল এক ঘর সরিয়ে দেয় এবং আবার তুলনা শুরু করে, যদিও অমিলের তথ্য আমাদের অনেক দূরে সরানোর নির্দেশ দিতে পারতো।

মৌলিক অপটিমাইজেশন কৌশল: কঠিন নয়, স্মার্টভাবে চিন্তা করা

সাধারণ পদ্ধতির সীমাবদ্ধতা কাটিয়ে ওঠার জন্য, কম্পিউটার বিজ্ঞানীরা চমৎকার অ্যালগরিদম তৈরি করেছেন যা অনুসন্ধান পর্বটিকে অবিশ্বাস্যভাবে দ্রুত করার জন্য প্রি-কম্পিউটেশন ব্যবহার করে। তারা প্রথমে প্যাটার্ন(গুলি) সম্পর্কে তথ্য সংগ্রহ করে, তারপর সেই তথ্য ব্যবহার করে অনুসন্ধানের সময় টেক্সটের বড় অংশ এড়িয়ে যায়।

একক প্যাটার্ন ম্যাচিং: বয়ার-মুর এবং KMP

যখন একটি একক প্যাটার্ন অনুসন্ধান করা হয়, তখন দুটি ক্লাসিক অ্যালগরিদম প্রাধান্য পায়: বয়ার-মুর এবং নুথ-মরিস-প্র্যাট (KMP)।

• বয়ার-মুর অ্যালগরিদম: এটি প্রায়শই বাস্তবসম্মত স্ট্রিং অনুসন্ধানের জন্য বেঞ্চমার্ক হিসেবে ব্যবহৃত হয়। এর প্রতিভা দুটি হিউরিস্টিকসের মধ্যে নিহিত। প্রথমত, এটি প্যাটার্নটিকে বাম থেকে ডানে না মিলিয়ে ডান থেকে বামে মেলায়। যখন একটি অমিল ঘটে, তখন এটি একটি প্রি-কম্পিউটেড 'ব্যাড ক্যারেক্টার টেবিল' ব্যবহার করে সর্বোচ্চ নিরাপদ শিফট নির্ধারণ করে। উদাহরণস্বরূপ, যদি আমরা "EXAMPLE" কে টেক্সটের সাথে মেলাতে গিয়ে একটি অমিল খুঁজে পাই, এবং টেক্সটের অক্ষরটি 'Z' হয়, আমরা জানি 'Z' "EXAMPLE" এর মধ্যে নেই, তাই আমরা পুরো প্যাটার্নটিকে এই বিন্দুর পর পর্যন্ত শিফট করতে পারি। এটি প্রায়শই বাস্তবে সাব-লিনিয়ার পারফরম্যান্স দেয়।
• নুথ-মরিস-প্র্যাট (KMP) অ্যালগরিদম: KMP এর উদ্ভাবন হল একটি প্রি-কম্পিউটেড 'প্রিফিক্স ফাংশন' বা লঙ্গেস্ট প্রোপার প্রিফিক্স সাফিক্স (LPS) অ্যারে। এই অ্যারেটি আমাদের বলে, প্যাটার্নের যেকোনো প্রিফিক্সের জন্য, দীর্ঘতম প্রোপার প্রিফিক্স যা একটি সাফিক্সও, তার দৈর্ঘ্য কত। এই তথ্যটি অ্যালগরিদমকে একটি অমিলের পরে অপ্রয়োজনীয় তুলনা এড়াতে সাহায্য করে। যখন একটি অমিল ঘটে, তখন এক ঘর শিফট করার পরিবর্তে, এটি LPS মানের উপর ভিত্তি করে প্যাটার্নটিকে শিফট করে, যা পূর্বে মিলে যাওয়া অংশ থেকে পাওয়া তথ্যকে কার্যকরভাবে পুনরায় ব্যবহার করে।

যদিও এগুলি একক-প্যাটার্ন অনুসন্ধানের জন্য আকর্ষণীয় এবং শক্তিশালী, আমাদের লক্ষ্য হল এমন একটি ইঞ্জিন তৈরি করা যা একাধিক প্যাটার্ন সর্বোচ্চ দক্ষতার সাথে পরিচালনা করে। তার জন্য, আমাদের একটি ভিন্ন ধরনের পদ্ধতির প্রয়োজন।

মাল্টি-প্যাটার্ন ম্যাচিং: আহো-কোরাসিক অ্যালগরিদম

আলফ্রেড আহো এবং মার্গারেট কোরাসিক দ্বারা বিকশিত আহো-কোরাসিক অ্যালগরিদম, একটি টেক্সটে একাধিক প্যাটার্ন খুঁজে বের করার জন্য निर्विवाद চ্যাম্পিয়ন। এটি সেই অ্যালগরিদম যা ইউনিক্স কমান্ড `fgrep` এর মতো সরঞ্জামগুলির ভিত্তি। এর জাদু হল যে এর অনুসন্ধানের সময় হল O(N + L + Z), যেখানে N হল টেক্সটের দৈর্ঘ্য, L হল সমস্ত প্যাটার্নের মোট দৈর্ঘ্য, এবং Z হল ম্যাচের সংখ্যা। লক্ষ্য করুন যে প্যাটার্নের সংখ্যা (K) অনুসন্ধানের কমপ্লেক্সিটিতে একটি গুণক নয়! এটি একটি বিশাল উন্নতি।

এটি কিভাবে অর্জন করে? দুটি মূল ডেটা স্ট্রাকচার একত্রিত করে:

1. একটি ট্রাই (প্রিফিক্স ট্রি): এটি প্রথমে সমস্ত প্যাটার্ন (আমাদের কীওয়ার্ডের অভিধান) ধারণকারী একটি ট্রাই তৈরি করে।
2. ফেইলিওর লিঙ্ক: তারপরে এটি ট্রাইটিকে 'ফেইলিওর লিঙ্ক' দিয়ে বর্ধিত করে। একটি নোডের জন্য একটি ফেইলিওর লিঙ্ক সেই নোড দ্বারা উপস্থাপিত স্ট্রিংয়ের দীর্ঘতম প্রোপার সাফিক্সের দিকে নির্দেশ করে যা ট্রাইয়ের কোনো প্যাটার্নের একটি প্রিফিক্সও।

এই সম্মিলিত কাঠামোটি একটি ফাইনাইট অটোমাটা গঠন করে। অনুসন্ধানের সময়, আমরা টেক্সটকে একবারে একটি করে অক্ষর প্রসেস করি, অটোমাটার মধ্য দিয়ে চলতে থাকি। যদি আমরা একটি ক্যারেক্টার লিঙ্ক অনুসরণ করতে না পারি, তাহলে আমরা একটি ফেইলিওর লিঙ্ক অনুসরণ করি। এটি ইনপুট টেক্সটের অক্ষরগুলি পুনরায় স্ক্যান না করেই অনুসন্ধান চালিয়ে যেতে দেয়।

রেগুলার এক্সপ্রেশন সম্পর্কে একটি নোট

জাভাস্ক্রিপ্টের `RegExp` ইঞ্জিন অবিশ্বাস্যভাবে শক্তিশালী এবং অত্যন্ত অপটিমাইজড, যা প্রায়শই নেটিভ C++ এ প্রয়োগ করা হয়। অনেক কাজের জন্য, একটি ভালভাবে লেখা রেজেক্সই সেরা টুল। তবে, এটি একটি পারফরম্যান্সের ফাঁদও হতে পারে।

• ক্যাটাসট্রোফিক ব্যাকট্র্যাকিং: নেস্টেড কোয়ান্টিফায়ার এবং অল্টারনেশন (যেমন, (a|b|c*)*) সহ খারাপভাবে নির্মিত রেজেক্স কিছু ইনপুটের উপর এক্সপোনেনশিয়াল রানটাইমের কারণ হতে পারে। এটি আপনার অ্যাপ্লিকেশন বা সার্ভারকে ফ্রিজ করে দিতে পারে।
• ওভারহেড: একটি জটিল রেজেক্স কম্পাইল করার একটি প্রাথমিক খরচ আছে। একটি বড় সেটের সরল, নির্দিষ্ট স্ট্রিং খোঁজার জন্য, আহো-কোরাসিকের মতো একটি বিশেষায়িত অ্যালগরিদমের চেয়ে রেজেক্স ইঞ্জিনের ওভারহেড বেশি হতে পারে।

অপটিমাইজেশন টিপ: একাধিক কীওয়ার্ডের জন্য রেজেক্স ব্যবহার করার সময়, সেগুলিকে দক্ষতার সাথে একত্রিত করুন। str.match(/cat|)|str.match(/dog/)|str.match(/bird/) এর পরিবর্তে একটি একক রেজেক্স ব্যবহার করুন: str.match(/cat|dog|bird/g)। ইঞ্জিন এই একক পাসটি অনেক ভালোভাবে অপটিমাইজ করতে পারে।

আমাদের আহো-কোরাসিক ইঞ্জিন তৈরি: একটি ধাপে ধাপে নির্দেশিকা

আসুন আমরা হাত গুটিয়ে জাভাস্ক্রিপ্টে এই শক্তিশালী ইঞ্জিনটি তৈরি করি। আমরা এটি তিনটি পর্যায়ে করব: বেসিক ট্রাই তৈরি করা, ফেইলিওর লিঙ্ক যোগ করা এবং অবশেষে, সার্চ ফাংশনটি প্রয়োগ করা।

ধাপ ১: ট্রাই ডেটা স্ট্রাকচার ফাউন্ডেশন

ট্রাই একটি ট্রি-এর মতো ডেটা স্ট্রাকচার যেখানে প্রতিটি নোড একটি অক্ষরকে প্রতিনিধিত্ব করে। রুট থেকে একটি নোড পর্যন্ত পাথ প্রিফিক্সকে প্রতিনিধিত্ব করে। আমরা সেই নোডগুলিতে একটি `output` অ্যারে যোগ করব যা একটি সম্পূর্ণ প্যাটার্নের সমাপ্তি নির্দেশ করে।

            
class TrieNode {
    constructor() {
        this.children = {}; // Maps characters to other TrieNodes
        this.isEndOfWord = false;
        this.output = []; // Stores patterns that end at this node
        this.failureLink = null; // To be added later
    }
}

class AhoCorasickEngine {
    constructor(patterns) {
        this.root = new TrieNode();
        this.buildTrie(patterns);
        this.buildFailureLinks();
    }

    /**
     * Builds the basic Trie from a list of patterns.
     */
    buildTrie(patterns) {
        for (const pattern of patterns) {
            if (typeof pattern !== 'string' || pattern.length === 0) continue;
            let currentNode = this.root;
            for (const char of pattern) {
                if (!currentNode.children[char]) {
                    currentNode.children[char] = new TrieNode();
                }
                currentNode = currentNode.children[char];
            }
            currentNode.isEndOfWord = true;
            currentNode.output.push(pattern);
        }
    }

    // ... buildFailureLinks and search methods to come
}

            

              
                Copy
              
            
          

ধাপ ২: ফেইলিওর লিঙ্কের জাল বোনা

এটি সবচেয়ে গুরুত্বপূর্ণ এবং ধারণাগতভাবে জটিল অংশ। আমরা রুট থেকে শুরু করে একটি ব্রেডথ-ফার্স্ট সার্চ (BFS) ব্যবহার করে প্রতিটি নোডের জন্য ফেইলিওর লিঙ্ক তৈরি করব। রুটের ফেইলিওর লিঙ্কটি নিজেকেই নির্দেশ করে। অন্য যেকোনো নোডের জন্য, তার ফেইলিওর লিঙ্কটি তার প্যারেন্টের ফেইলিওর লিঙ্ক ট্র্যাভার্স করে এবং বর্তমান নোডের অক্ষরের জন্য একটি পাথ বিদ্যমান কিনা তা দেখে পাওয়া যায়।

            
// Add this method inside the AhoCorasickEngine class

buildFailureLinks() {
    const queue = [];
    this.root.failureLink = this.root; // The root's failure link points to itself

    // Start BFS with the children of the root
    for (const char in this.root.children) {
        const node = this.root.children[char];
        node.failureLink = this.root;
        queue.push(node);
    }

    while (queue.length > 0) {
        const currentNode = queue.shift();

        for (const char in currentNode.children) {
            const nextNode = currentNode.children[char];
            let failureNode = currentNode.failureLink;

            // Traverse failure links until we find a node with a transition for the current character,
            // or we reach the root.
            while (failureNode.children[char] === undefined && failureNode !== this.root) {
                failureNode = failureNode.failureLink;
            }

            if (failureNode.children[char]) {
                nextNode.failureLink = failureNode.children[char];
            } else {
                nextNode.failureLink = this.root;
            }

            // Also, merge the output of the failure link node with the current node's output.
            // This ensures we find patterns that are suffixes of other patterns (e.g., finding "he" in "she").
            nextNode.output.push(...nextNode.failureLink.output);

            queue.push(nextNode);
        }
    }
}

            

              
                Copy
              
            
          

ধাপ ৩: উচ্চ-গতির সার্চ ফাংশন

আমাদের সম্পূর্ণ নির্মিত অটোমাটা দিয়ে, অনুসন্ধানটি মার্জিত এবং দক্ষ হয়ে ওঠে। আমরা ইনপুট টেক্সটকে অক্ষর-দ্বারা-অক্ষর ট্র্যাভার্স করি, আমাদের ট্রাইয়ের মধ্য দিয়ে যাই। যদি একটি সরাসরি পাথ বিদ্যমান না থাকে, আমরা একটি মিল খুঁজে না পাওয়া পর্যন্ত বা রুটে ফিরে না আসা পর্যন্ত ফেইলিওর লিঙ্ক অনুসরণ করি। প্রতিটি ধাপে, আমরা যেকোনো ম্যাচের জন্য বর্তমান নোডের `output` অ্যারে পরীক্ষা করি।

            
// Add this method inside the AhoCorasickEngine class

search(text) {
    let currentNode = this.root;
    const results = [];

    for (let i = 0; i < text.length; i++) {
        const char = text[i];

        while (currentNode.children[char] === undefined && currentNode !== this.root) {
            currentNode = currentNode.failureLink;
        }

        if (currentNode.children[char]) {
            currentNode = currentNode.children[char];
        } 
        // If we are at the root and there's no path for the current char, we stay at the root.

        if (currentNode.output.length > 0) {
            for (const pattern of currentNode.output) {
                results.push({
                    pattern: pattern,
                    index: i - pattern.length + 1
                });
            }
        }
    }

    return results;
}

            

              
                Copy
              
            
          

সবকিছু একসাথে: একটি সম্পূর্ণ উদাহরণ

            
// (Include the full TrieNode and AhoCorasickEngine class definitions from above)

const patterns = ["he", "she", "his", "hers"];
const text = "ushers";

const engine = new AhoCorasickEngine(patterns);
const matches = engine.search(text);

console.log(matches);
// Expected Output:
// [
//   { pattern: 'he', index: 2 },
//   { pattern: 'she', index: 1 },
//   { pattern: 'hers', index: 2 }
// ]

            

              
                Copy
              
            
          

লক্ষ্য করুন কিভাবে আমাদের ইঞ্জিন "ushers" এর ইনডেক্স ৫-এ শেষ হওয়া "he" এবং "hers" এবং ইনডেক্স ৩-এ শেষ হওয়া "she" কে সঠিকভাবে খুঁজে পেয়েছে। এটি ফেইলিওর লিঙ্ক এবং মার্জড আউটপুটের শক্তি প্রদর্শন করে।

অ্যালগরিদমের বাইরে: ইঞ্জিন-স্তরের এবং পরিবেশগত অপটিমাইজেশন

একটি দুর্দান্ত অ্যালগরিদম আমাদের ইঞ্জিনের হৃদয়, কিন্তু V8 (ক্রোম এবং Node.js-এ) এর মতো একটি জাভাস্ক্রিপ্ট পরিবেশে সর্বোচ্চ পারফরম্যান্সের জন্য, আমরা আরও অপটিমাইজেশন বিবেচনা করতে পারি।

• প্রি-কম্পিউটেশনই মূল চাবিকাঠি: আহো-কোরাসিক অটোমাটা তৈরির খরচ শুধুমাত্র একবারই দিতে হয়। যদি আপনার প্যাটার্নের সেট স্থির থাকে (যেমন একটি WAF রুলসেট বা একটি গালিগালাজ ফিল্টার), ইঞ্জিনটি একবার তৈরি করুন এবং লক্ষ লক্ষ অনুসন্ধানের জন্য এটি পুনরায় ব্যবহার করুন। এটি সেটআপ খরচকে প্রায় শূন্যে নামিয়ে আনে।
• স্ট্রিং রিপ্রেজেন্টেশন: জাভাস্ক্রিপ্ট ইঞ্জিনগুলিতে অত্যন্ত অপটিমাইজড অভ্যন্তরীণ স্ট্রিং রিপ্রেজেন্টেশন রয়েছে। একটি টাইট লুপে অনেক ছোট সাবস্ট্রিং তৈরি করা এড়িয়ে চলুন (যেমন, বারবার text.substring() ব্যবহার করা)। ইনডেক্স দ্বারা অক্ষর অ্যাক্সেস করা (text[i]) সাধারণত খুব দ্রুত।
• মেমরি ম্যানেজমেন্ট: একটি অত্যন্ত বড় প্যাটার্নের সেটের জন্য, ট্রাই উল্লেখযোগ্য পরিমাণে মেমরি খরচ করতে পারে। এই বিষয়ে সচেতন থাকুন। এই ধরনের ক্ষেত্রে, রোলিং হ্যাশ সহ রাবিন-কার্পের মতো অন্যান্য অ্যালগরিদম গতি এবং মেমরির মধ্যে একটি ভিন্ন ট্রেড-অফ অফার করতে পারে।
• ওয়েবঅ্যাসেম্বলি (WASM): সবচেয়ে বেশি চাহিদাযুক্ত, পারফরম্যান্স-ক্রিটিক্যাল কাজের জন্য, আপনি মূল ম্যাচিং লজিকটি রাস্ট বা C++ এর মতো একটি ভাষায় প্রয়োগ করতে পারেন এবং এটিকে ওয়েবঅ্যাসেম্বলিতে কম্পাইল করতে পারেন। এটি আপনাকে প্রায়-নেটিভ পারফরম্যান্স দেয়, আপনার কোডের হট পাথের জন্য জাভাস্ক্রিপ্ট ইন্টারপ্রেটার এবং JIT কম্পাইলারকে বাইপাস করে। এটি একটি উন্নত কৌশল কিন্তু চূড়ান্ত গতি প্রদান করে।

বেঞ্চমার্কিং: অনুমান নয়, প্রমাণ করুন

যা আপনি পরিমাপ করতে পারবেন না, তা অপটিমাইজ করতে পারবেন না। আমাদের কাস্টম ইঞ্জিনটি যে সহজ বিকল্পগুলির চেয়ে সত্যিই দ্রুত তা যাচাই করার জন্য একটি সঠিক বেঞ্চমার্ক সেট আপ করা অত্যন্ত গুরুত্বপূর্ণ।

আসুন একটি কাল্পনিক পরীক্ষা ডিজাইন করি:

• টেক্সট: একটি ৫MB টেক্সট ফাইল (যেমন, একটি উপন্যাস)।
• প্যাটার্ন: ৫০০টি সাধারণ ইংরেজি শব্দের একটি অ্যারে।

আমরা চারটি পদ্ধতির তুলনা করব:

1. `indexOf` সহ সরল লুপ: সমস্ত ৫০০টি প্যাটার্নের মধ্য দিয়ে লুপ করুন এবং প্রতিটির জন্য text.indexOf(pattern) কল করুন।
2. একক কম্পাইলড RegExp: সমস্ত প্যাটার্নকে একটি রেজেক্সে একত্রিত করুন যেমন /word1|word2|...|word500/g এবং text.match() চালান।
3. আমাদের আহো-কোরাসিক ইঞ্জিন: ইঞ্জিনটি একবার তৈরি করুন, তারপর অনুসন্ধান চালান।
4. সাধারণ ব্রুট-ফোর্স: O(K * N * M) পদ্ধতি।

একটি সাধারণ বেঞ্চমার্ক স্ক্রিপ্ট এইরকম দেখতে হতে পারে:

            
console.time("Aho-Corasick Search");
const matches = engine.search(largeText);
console.timeEnd("Aho-Corasick Search");

// Repeat for other methods...

            

              
                Copy
              
            
          

প্রত্যাশিত ফলাফল (উদাহরণস্বরূপ):

• সাধারণ ব্রুট-ফোর্স: > ১০,০০০ ms (বা পরিমাপের জন্য খুব ধীর)
• `indexOf` সহ সরল লুপ: ~১৫০০ ms
• একক কম্পাইলড RegExp: ~৩০০ ms
• আহো-কোরাসিক ইঞ্জিন: ~৫০ ms

ফলাফলগুলি স্পষ্টভাবে আর্কিটেকচারাল সুবিধা দেখায়। যদিও অত্যন্ত অপটিমাইজড নেটিভ RegExp ইঞ্জিন ম্যানুয়াল লুপগুলির চেয়ে একটি বিশাল উন্নতি, আহো-কোরাসিক অ্যালগরিদম, যা বিশেষভাবে এই সমস্যার জন্য ডিজাইন করা হয়েছে, আরও এক ধাপ দ্রুততর কর্মক্ষমতা প্রদান করে।

উপসংহার: কাজের জন্য সঠিক সরঞ্জাম নির্বাচন করা

স্ট্রিং প্যাটার্ন অপটিমাইজেশনের যাত্রা সফ্টওয়্যার ইঞ্জিনিয়ারিংয়ের একটি মৌলিক সত্য প্রকাশ করে: যদিও উচ্চ-স্তরের অ্যাবস্ট্রাকশন এবং বিল্ট-ইন ফাংশনগুলি উৎপাদনশীলতার জন্য অমূল্য, অন্তর্নিহিত নীতিগুলির গভীর উপলব্ধিই আমাদের সত্যিকারের উচ্চ-পারফরম্যান্স সিস্টেম তৈরি করতে সক্ষম করে।

আমরা শিখেছি যে:

• সাধারণ পদ্ধতি সহজ কিন্তু খারাপভাবে স্কেল করে, যা এটিকে চাহিদাযুক্ত অ্যাপ্লিকেশনের জন্য অনুপযুক্ত করে তোলে।
• জাভাস্ক্রিপ্টের `RegExp` ইঞ্জিন একটি শক্তিশালী এবং দ্রুত টুল, কিন্তু পারফরম্যান্সের ঝুঁকি এড়াতে সতর্ক প্যাটার্ন নির্মাণের প্রয়োজন এবং হাজার হাজার নির্দিষ্ট স্ট্রিং মেলানোর জন্য এটি সর্বোত্তম পছন্দ নাও হতে পারে।
• আহো-কোরাসিক-এর মতো বিশেষায়িত অ্যালগরিদমগুলি লিনিয়ার সার্চ টাইম অর্জনের জন্য চতুর প্রি-কম্পিউটেশন (ট্রাই এবং ফেইলিওর লিঙ্ক) ব্যবহার করে মাল্টি-প্যাটার্ন ম্যাচিং-এর পারফরম্যান্সে একটি উল্লেখযোগ্য লাফ দেয়।

একটি কাস্টম স্ট্রিং ম্যাচিং ইঞ্জিন তৈরি করা প্রতিটি প্রকল্পের জন্য একটি কাজ নয়। কিন্তু যখন আপনি টেক্সট প্রসেসিংয়ে একটি পারফরম্যান্সের বাধার সম্মুখীন হন, তা Node.js ব্যাকএন্ডে, ক্লায়েন্ট-সাইড সার্চ ফিচারে, বা একটি নিরাপত্তা বিশ্লেষণ টুলে হোক না কেন, আপনার কাছে এখন স্ট্যান্ডার্ড লাইব্রেরির বাইরে দেখার জ্ঞান আছে। সঠিক অ্যালগরিদম এবং ডেটা স্ট্রাকচার বেছে নেওয়ার মাধ্যমে, আপনি একটি ধীর, সম্পদ-নিবিড় প্রক্রিয়াকে একটি চর্বিহীন, দক্ষ এবং স্কেলেবল সমাধানে রূপান্তর করতে পারেন।