જાવાસ્ક્રિપ્ટના કોરને ઓપ્ટિમાઇઝ કરવું: એક ઉચ્ચ-પ્રદર્શન સ્ટ્રિંગ પેટર્ન મેચિંગ એન્જિનનું નિર્માણ

સોફ્ટવેર ડેવલપમેન્ટના વિશાળ વિશ્વમાં, સ્ટ્રિંગ પ્રોસેસિંગ એક મૂળભૂત અને સર્વવ્યાપક કાર્ય છે. ટેક્સ્ટ એડિટરમાં સાદા 'ફાઇન્ડ એન્ડ રિપ્લેસ' થી માંડીને નેટવર્ક ટ્રાફિકમાં દૂષિત પેલોડ્સ માટે સ્કેન કરતી અત્યાધુનિક ઇન્ટ્રુઝન ડિટેક્શન સિસ્ટમ્સ સુધી, ટેક્સ્ટમાં પેટર્ન શોધવાની કાર્યક્ષમ ક્ષમતા આધુનિક કમ્પ્યુટિંગનો આધારસ્તંભ છે. જાવાસ્ક્રિપ્ટ ડેવલપર્સ માટે, જેઓ એવા વાતાવરણમાં કાર્ય કરે છે જ્યાં પ્રદર્શન સીધું જ વપરાશકર્તાના અનુભવ અને સર્વર ખર્ચને અસર કરે છે, સ્ટ્રિંગ પેટર્ન મેચિંગની ગૂંચવણોને સમજવી એ માત્ર શૈક્ષણિક કસરત નથી—તે એક મહત્વપૂર્ણ વ્યાવસાયિક કૌશલ્ય છે.

જ્યારે જાવાસ્ક્રિપ્ટની બિલ્ટ-ઇન પદ્ધતિઓ જેવી કે String.prototype.indexOf(), includes(), અને શક્તિશાળી RegExp એન્જિન રોજિંદા કાર્યો માટે સારી રીતે સેવા આપે છે, ત્યારે ઉચ્ચ-થ્રુપુટ એપ્લિકેશન્સમાં તે પ્રદર્શન અવરોધો બની શકે છે. જ્યારે તમારે વિશાળ દસ્તાવેજમાં હજારો કીવર્ડ્સ શોધવાની જરૂર હોય, અથવા લાખો લોગ એન્ટ્રીઓને નિયમોના સમૂહ સામે માન્ય કરવાની જરૂર હોય, ત્યારે સરળ અભિગમ સ્કેલ કરી શકશે નહીં. આ તે સ્થાન છે જ્યાં આપણે આપણું પોતાનું ઓપ્ટિમાઇઝ્ડ સ્ટ્રિંગ પ્રોસેસિંગ એન્જિન બનાવવા માટે કમ્પ્યુટર સાયન્સ અલ્ગોરિધમ્સ અને ડેટા સ્ટ્રક્ચર્સની દુનિયામાં, સ્ટાન્ડર્ડ લાઇબ્રેરીથી પરે, વધુ ઊંડાણપૂર્વક જોવું જોઈએ.

આ વ્યાપક માર્ગદર્શિકા તમને મૂળભૂત, બ્રુટ-ફોર્સ પદ્ધતિઓથી માંડીને એહો-કોરાસિક જેવી અદ્યતન, ઉચ્ચ-પ્રદર્શન અલ્ગોરિધમ્સ સુધીની સફર પર લઈ જશે. અમે વિશ્લેષણ કરીશું કે દબાણ હેઠળ અમુક અભિગમો શા માટે નિષ્ફળ જાય છે અને અન્ય, ચતુર પ્રી-કમ્પ્યુટેશન અને સ્ટેટ મેનેજમેન્ટ દ્વારા, લીનિયર-ટાઇમ કાર્યક્ષમતા કેવી રીતે પ્રાપ્ત કરે છે. અંત સુધીમાં, તમે માત્ર સિદ્ધાંત જ નહીં સમજી શકશો, પણ શરૂઆતથી જાવાસ્ક્રિપ્ટમાં એક વ્યવહારુ, ઉચ્ચ-પ્રદર્શન, મલ્ટિ-પેટર્ન મેચિંગ એન્જિન બનાવવામાં પણ સક્ષમ હશો.

સ્ટ્રિંગ મેચિંગનું વ્યાપક સ્વરૂપ

કોડમાં ડૂબકી મારતા પહેલાં, કાર્યક્ષમ સ્ટ્રિંગ મેચિંગ પર આધાર રાખતી એપ્લિકેશન્સની વ્યાપકતાને સમજવી જરૂરી છે. આ ઉપયોગના કિસ્સાઓને ઓળખવાથી ઓપ્ટિમાઇઝેશનના મહત્વને સંદર્ભિત કરવામાં મદદ મળે છે.

• વેબ એપ્લિકેશન ફાયરવોલ્સ (WAFs): સુરક્ષા સિસ્ટમ્સ હજારો જાણીતા હુમલાના સિગ્નેચર્સ (દા.ત., SQL ઇન્જેક્શન, ક્રોસ-સાઇટ સ્ક્રિપ્ટીંગ પેટર્ન્સ) માટે આવનારી HTTP વિનંતીઓને સ્કેન કરે છે. વપરાશકર્તાની વિનંતીઓમાં વિલંબ ટાળવા માટે આ માઇક્રોસેકન્ડ્સમાં થવું આવશ્યક છે.
• ટેક્સ્ટ એડિટર્સ અને IDEs: સિન્ટેક્સ હાઇલાઇટિંગ, ઇન્ટેલિજન્ટ સર્ચ અને 'ફાઇન્ડ ઓલ ઓકરન્સીસ' જેવી સુવિધાઓ સંભવિત મોટી સોર્સ કોડ ફાઇલોમાં બહુવિધ કીવર્ડ્સ અને પેટર્ન્સને ઝડપથી ઓળખવા પર આધાર રાખે છે.
• કન્ટેન્ટ ફિલ્ટરિંગ અને મોડરેશન: સોશિયલ મીડિયા પ્લેટફોર્મ્સ અને ફોરમ્સ વપરાશકર્તા દ્વારા જનરેટ કરેલા કન્ટેન્ટને અયોગ્ય શબ્દો અથવા શબ્દસમૂહોના મોટા શબ્દકોશ સામે રીઅલ-ટાઇમમાં સ્કેન કરે છે.
• બાયોઇન્ફોર્મેટિક્સ: વૈજ્ઞાનિકો વિશાળ DNA સ્ટ્રેન્ડ્સ (ટેક્સ્ટ) માં ચોક્કસ જનીન ક્રમ (પેટર્ન્સ) શોધે છે. આ અલ્ગોરિધમ્સની કાર્યક્ષમતા જેનોમિક સંશોધન માટે સર્વોપરી છે.
• ડેટા લોસ પ્રિવેન્શન (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) ની સમય જટિલતા આપે છે. નાની સ્ટ્રિંગ્સ માટે, આ સંપૂર્ણપણે બરાબર છે. પરંતુ 10MB ટેક્સ્ટ (≈10,000,000 અક્ષરો) અને 100-અક્ષરની પેટર્નનો વિચાર કરો. સરખામણીઓની સંખ્યા અબજોમાં હોઈ શકે છે.

હવે, જો આપણે 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. A Trie (Prefix Tree): તે પ્રથમ બધી પેટર્ન (આપણા કીવર્ડ્સનો શબ્દકોશ) ધરાવતું એક ટ્રાઈ બનાવે છે.
2. Failure Links: તે પછી 'ફેઈલ્યોર લિંક્સ' સાથે ટ્રાઈને વિસ્તૃત કરે છે. નોડ માટે ફેઈલ્યોર લિંક તે નોડ દ્વારા રજૂ કરાયેલ સ્ટ્રિંગના સૌથી લાંબા પ્રોપર સફિક્સ તરફ નિર્દેશ કરે છે જે ટ્રાઈમાં કોઈ પેટર્નનો પ્રીફિક્સ પણ છે.

આ સંયુક્ત માળખું એક ફાઈનાઈટ ઓટોમેટન બનાવે છે. શોધ દરમિયાન, આપણે ટેક્સ્ટને એક સમયે એક અક્ષર પ્રોસેસ કરીએ છીએ, ઓટોમેટનમાંથી પસાર થઈએ છીએ. જો આપણે કેરેક્ટર લિંકને અનુસરી ન શકીએ, તો આપણે ફેઈલ્યોર લિંકને અનુસરીએ છીએ. આ ઇનપુટ ટેક્સ્ટમાં અક્ષરોને ફરીથી સ્કેન કર્યા વિના શોધ ચાલુ રાખવાની મંજૂરી આપે છે.

રેગ્યુલર એક્સપ્રેશન્સ પર એક નોંધ

જાવાસ્ક્રિપ્ટનું `RegExp` એન્જિન અત્યંત શક્તિશાળી અને ઉચ્ચ સ્તરે ઓપ્ટિમાઇઝ્ડ છે, જે ઘણીવાર નેટિવ C++ માં લાગુ કરવામાં આવે છે. ઘણા કાર્યો માટે, સારી રીતે લખાયેલ રેજેક્સ શ્રેષ્ઠ સાધન છે. જોકે, તે પર્ફોર્મન્સ ટ્રેપ પણ હોઈ શકે છે.

• કેટાસ્ટ્રોફિક બેકટ્રેકિંગ: નેસ્ટેડ ક્વોન્ટિફાયર્સ અને ઓલ્ટરનેશન (દા.ત., (a|b|c*)*) સાથે ખરાબ રીતે બનાવેલ રેજેક્સ અમુક ઇનપુટ્સ પર એક્સપોનેન્શિયલ રનટાઇમ તરફ દોરી શકે છે. આ તમારી એપ્લિકેશન અથવા સર્વરને ફ્રીઝ કરી શકે છે.
• ઓવરહેડ: જટિલ રેજેક્સનું કમ્પાઈલિંગ કરવાનો પ્રારંભિક ખર્ચ હોય છે. સાદી, નિશ્ચિત સ્ટ્રિંગ્સના મોટા સમૂહને શોધવા માટે, રેજેક્સ એન્જિનનો ઓવરહેડ એહો-કોરાસિક જેવા વિશિષ્ટ અલ્ગોરિધમ કરતાં વધુ હોઈ શકે છે.

ઓપ્ટિમાઇઝેશન ટિપ: બહુવિધ કીવર્ડ્સ માટે રેજેક્સનો ઉપયોગ કરતી વખતે, તેમને અસરકારક રીતે જોડો. str.match(/cat|)|str.match(/dog/)|str.match(/bird/) ને બદલે, એક જ રેજેક્સનો ઉપયોગ કરો: str.match(/cat|dog|bird/g). એન્જિન આ સિંગલ પાસને વધુ સારી રીતે ઓપ્ટિમાઇઝ કરી શકે છે.

આપણા એહો-કોરાસિક એન્જિનનું નિર્માણ: એક સ્ટેપ-બાય-સ્ટેપ માર્ગદર્શિકા

ચાલો આપણે આપણી સ્લીવ્ઝ ચડાવીએ અને જાવાસ્ક્રિપ્ટમાં આ શક્તિશાળી એન્જિન બનાવીએ. આપણે તેને ત્રણ તબક્કામાં કરીશું: મૂળભૂત ટ્રાઈનું નિર્માણ, ફેઈલ્યોર લિંક્સ ઉમેરવી, અને છેવટે, શોધ ફંક્શનનો અમલ કરવો.

સ્ટેપ 1: ટ્રાઈ ડેટા સ્ટ્રક્ચરનો પાયો

ટ્રાઈ એક વૃક્ષ જેવી ડેટા સ્ટ્રક્ચર છે જ્યાં દરેક નોડ એક અક્ષરનું પ્રતિનિધિત્વ કરે છે. રુટથી નોડ સુધીના પાથ પ્રીફિક્સનું પ્રતિનિધિત્વ કરે છે. અમે તે નોડ્સમાં એક `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
              
            
          

સ્ટેપ 2: ફેઈલ્યોર લિંક્સનું જાળું ગૂંથવું

આ સૌથી મહત્વપૂર્ણ અને વૈચારિક રીતે જટિલ ભાગ છે. અમે દરેક નોડ માટે ફેઈલ્યોર લિંક્સ બનાવવા માટે રુટથી શરૂ કરીને બ્રેડ્થ-ફર્સ્ટ સર્ચ (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
              
            
          

સ્ટેપ 3: હાઇ-સ્પીડ સર્ચ ફંક્શન

આપણા સંપૂર્ણપણે નિર્મિત ઓટોમેટન સાથે, શોધ ભવ્ય અને કાર્યક્ષમ બની જાય છે. આપણે ઇનપુટ ટેક્સ્ટને અક્ષર દ્વારા અક્ષર ટ્રેવર્સ કરીએ છીએ, આપણા ટ્રાઈમાંથી પસાર થઈએ છીએ. જો સીધો પાથ અસ્તિત્વમાં ન હોય, તો આપણે મેચ ન મળે અથવા રુટ પર પાછા ન ફરો ત્યાં સુધી ફેઈલ્યોર લિંકને અનુસરીએ છીએ. દરેક પગલા પર, આપણે કોઈપણ મેચ માટે વર્તમાન નોડના `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" ના ઇન્ડેક્સ 5 પર સમાપ્ત થતા "he" અને "hers" અને ઇન્ડેક્સ 3 પર સમાપ્ત થતા "she" ને યોગ્ય રીતે શોધી કાઢ્યા. આ ફેઈલ્યોર લિંક્સ અને મર્જ થયેલા આઉટપુટની શક્તિ દર્શાવે છે.

અલ્ગોરિધમથી પરે: એન્જિન-સ્તર અને પર્યાવરણીય ઓપ્ટિમાઇઝેશન્સ

એક મહાન અલ્ગોરિધમ આપણા એન્જિનનું હૃદય છે, પરંતુ V8 (ક્રોમ અને Node.js માં) જેવા જાવાસ્ક્રિપ્ટ વાતાવરણમાં ટોચના પ્રદર્શન માટે, આપણે વધુ ઓપ્ટિમાઇઝેશનનો વિચાર કરી શકીએ છીએ.

• પ્રી-કમ્પ્યુટેશન ચાવીરૂપ છે: એહો-કોરાસિક ઓટોમેટન બનાવવાનો ખર્ચ માત્ર એક જ વાર ચૂકવવામાં આવે છે. જો તમારી પેટર્નનો સેટ સ્થિર હોય (જેમ કે WAF નિયમસેટ અથવા અપશબ્દ ફિલ્ટર), તો એન્જિન એકવાર બનાવો અને લાખો શોધ માટે તેનો પુનઃઉપયોગ કરો. આ સેટઅપ ખર્ચને લગભગ શૂન્ય સુધી ઘટાડે છે.
• સ્ટ્રિંગ પ્રતિનિધિત્વ: જાવાસ્ક્રિપ્ટ એન્જિનમાં અત્યંત ઓપ્ટિમાઇઝ્ડ આંતરિક સ્ટ્રિંગ પ્રતિનિધિત્વ હોય છે. ટાઇટ લૂપમાં ઘણી નાની સબસ્ટ્રિંગ બનાવવાનું ટાળો (દા.ત., text.substring() નો વારંવાર ઉપયોગ કરવો). ઇન્ડેક્સ દ્વારા અક્ષરોને એક્સેસ કરવું (text[i]) સામાન્ય રીતે ખૂબ જ ઝડપી હોય છે.
• મેમરી મેનેજમેન્ટ: પેટર્નના અત્યંત મોટા સેટ માટે, ટ્રાઈ નોંધપાત્ર મેમરીનો વપરાશ કરી શકે છે. આ બાબતે સાવચેત રહો. આવા કિસ્સાઓમાં, રોલિંગ હેશ સાથેના રાબિન-કાર્પ જેવા અન્ય અલ્ગોરિધમ્સ ગતિ અને મેમરી વચ્ચે અલગ ટ્રેડ-ઓફ ઓફર કરી શકે છે.
• વેબએસેમ્બલી (WASM): સૌથી વધુ માંગવાળી, પ્રદર્શન-જટિલ કાર્યો માટે, તમે રસ્ટ અથવા C++ જેવી ભાષામાં કોર મેચિંગ લોજિકનો અમલ કરી શકો છો અને તેને વેબએસેમ્બલીમાં કમ્પાઈલ કરી શકો છો. આ તમને લગભગ-નેટિવ પ્રદર્શન આપે છે, જે તમારા કોડના હોટ પાથ માટે જાવાસ્ક્રિપ્ટ ઇન્ટરપ્રીટર અને JIT કમ્પાઈલરને બાયપાસ કરે છે. આ એક અદ્યતન તકનીક છે પરંતુ અંતિમ ગતિ પ્રદાન કરે છે.

બેન્ચમાર્કિંગ: સાબિત કરો, ધારો નહીં

તમે જે માપી શકતા નથી તેને તમે ઓપ્ટિમાઇઝ કરી શકતા નથી. આપણું કસ્ટમ એન્જિન ખરેખર સરળ વિકલ્પો કરતાં ઝડપી છે તે માન્ય કરવા માટે યોગ્ય બેન્ચમાર્ક સેટ કરવું નિર્ણાયક છે.

ચાલો એક કાલ્પનિક ટેસ્ટ કેસ ડિઝાઇન કરીએ:

• ટેક્સ્ટ: એક 5MB ટેક્સ્ટ ફાઇલ (દા.ત., એક નવલકથા).
• પેટર્ન્સ: 500 સામાન્ય અંગ્રેજી શબ્દોની એક એરે.

આપણે ચાર પદ્ધતિઓની તુલના કરીશું:

1. indexOf સાથે સિમ્પલ લૂપ: બધી 500 પેટર્નમાંથી લૂપ કરો અને દરેક માટે 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
              
            
          

અપેક્ષિત પરિણામો (ઉદાહરણાત્મક):

• નાઈવ બ્રુટ-ફોર્સ: > 10,000 ms (અથવા માપવા માટે ખૂબ ધીમું)
• indexOf સાથે સિમ્પલ લૂપ: ~1500 ms
• સિંગલ કમ્પાઈલ્ડ RegExp: ~300 ms
• એહો-કોરાસિક એન્જિન: ~50 ms

પરિણામો સ્પષ્ટપણે આર્કિટેક્ચરલ ફાયદો દર્શાવે છે. જ્યારે ઉચ્ચ-ઓપ્ટિમાઇઝ્ડ નેટિવ RegExp એન્જિન મેન્યુઅલ લૂપ્સ પર એક મોટો સુધારો છે, ત્યારે એહો-કોરાસિક અલ્ગોરિધમ, જે ખાસ કરીને આ ચોક્કસ સમસ્યા માટે રચાયેલ છે, તે અન્ય ઓર્ડર-ઓફ-મેગ્નિટ્યુડ સ્પીડઅપ પ્રદાન કરે છે.

નિષ્કર્ષ: કામ માટે યોગ્ય સાધન પસંદ કરવું

સ્ટ્રિંગ પેટર્ન ઓપ્ટિમાઇઝેશનની આ સફર સોફ્ટવેર એન્જિનિયરિંગના એક મૂળભૂત સત્યને ઉજાગર કરે છે: જ્યારે ઉચ્ચ-સ્તરના એબ્સ્ટ્રેક્શન્સ અને બિલ્ટ-ઇન ફંક્શન્સ ઉત્પાદકતા માટે અમૂલ્ય છે, ત્યારે અંતર્ગત સિદ્ધાંતોની ઊંડી સમજ એ છે જે આપણને ખરેખર ઉચ્ચ-પ્રદર્શન સિસ્ટમ્સ બનાવવામાં સક્ષમ બનાવે છે.

આપણે શીખ્યા છીએ કે:

• સરળ અભિગમ સાદો છે પરંતુ નબળી રીતે સ્કેલ કરે છે, જે તેને માંગવાળી એપ્લિકેશન્સ માટે અયોગ્ય બનાવે છે.
• જાવાસ્ક્રિપ્ટનું `RegExp` એન્જિન એક શક્તિશાળી અને ઝડપી સાધન છે, પરંતુ પર્ફોર્મન્સની મુશ્કેલીઓ ટાળવા માટે તેને સાવચેતીપૂર્વક પેટર્ન બાંધકામની જરૂર છે અને હજારો નિશ્ચિત સ્ટ્રિંગ્સ મેચ કરવા માટે તે શ્રેષ્ઠ પસંદગી ન હોઈ શકે.
• એહો-કોરાસિક જેવા વિશિષ્ટ અલ્ગોરિધમ્સ લીનિયર શોધ સમય પ્રાપ્ત કરવા માટે ચતુર પ્રી-કમ્પ્યુટેશન (ટ્રાઈઝ અને ફેઈલ્યોર લિંક્સ) નો ઉપયોગ કરીને મલ્ટિ-પેટર્ન મેચિંગમાં પ્રદર્શનમાં નોંધપાત્ર ઉછાળો પ્રદાન કરે છે.

કસ્ટમ સ્ટ્રિંગ મેચિંગ એન્જિન બનાવવું એ દરેક પ્રોજેક્ટ માટેનું કાર્ય નથી. પરંતુ જ્યારે તમે Node.js બેકએન્ડ, ક્લાયન્ટ-સાઇડ શોધ સુવિધા, અથવા સુરક્ષા વિશ્લેષણ ટૂલમાં ટેક્સ્ટ પ્રોસેસિંગમાં પર્ફોર્મન્સ અવરોધનો સામનો કરો છો, ત્યારે હવે તમારી પાસે સ્ટાન્ડર્ડ લાઇબ્રેરીથી આગળ જોવાનું જ્ઞાન છે. યોગ્ય અલ્ગોરિધમ અને ડેટા સ્ટ્રક્ચર પસંદ કરીને, તમે ધીમી, સંસાધન-સઘન પ્રક્રિયાને એક સરળ, કાર્યક્ષમ અને સ્કેલેબલ ઉકેલમાં પરિવર્તિત કરી શકો છો.