ജാവാസ്ക്രിപ്റ്റിലെ സ്ട്രിംഗ് സെർച്ച് ടെക്നിക്കുകൾ
JavaScript ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, ഒരു സ്ട്രിംഗിൽ ഒരു പ്രത്യേക സബ്സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് നിങ്ങൾ സ്വയം പരിശോധിക്കേണ്ടതായി വന്നേക്കാം. അതിശയകരമെന്നു പറയട്ടെ, നേരായ ഒരു `ഉൾക്കൊള്ളുന്നു' രീതി ലഭ്യമല്ല.
എന്നിരുന്നാലും, ഇത് നേടുന്നതിന് JavaScript നിരവധി ബദൽ രീതികൾ വാഗ്ദാനം ചെയ്യുന്നു. ഈ ലേഖനത്തിൽ, നിങ്ങളുടെ കോഡ് ശുദ്ധവും കാര്യക്ഷമവുമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, ഒരു സ്ട്രിംഗിൽ ഒരു സബ്സ്ട്രിംഗ് ഉൾപ്പെട്ടിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നതിനുള്ള ഏറ്റവും ഫലപ്രദമായ മാർഗ്ഗങ്ങൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.
| കമാൻഡ് | വിവരണം |
|---|---|
| indexOf() | ഒരു സ്ട്രിംഗിൽ ഒരു നിർദ്ദിഷ്ട മൂല്യത്തിൻ്റെ ആദ്യ സംഭവത്തിൻ്റെ സൂചിക നൽകുന്നു. മൂല്യം കണ്ടെത്തിയില്ലെങ്കിൽ -1 നൽകുന്നു. |
| includes() | ഒരു സ്ട്രിംഗിൽ ഒരു നിർദ്ദിഷ്ട സബ്സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു. ശരിയോ തെറ്റോ നൽകുന്നു. |
| RegExp() | ഒരു പാറ്റേൺ ഉപയോഗിച്ച് ടെക്സ്റ്റ് പൊരുത്തപ്പെടുത്തുന്നതിന് ഒരു സാധാരണ എക്‌സ്‌പ്രഷൻ ഒബ്ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു. |
| test() | ഒരു സാധാരണ എക്‌സ്‌പ്രഷൻ ഉപയോഗിച്ച് ഒരു സ്‌ട്രിംഗിലെ പൊരുത്തം പരീക്ഷിക്കുന്നു. ശരിയോ തെറ്റോ നൽകുന്നു. |
| search() | ഒരു നിർദ്ദിഷ്ട മൂല്യത്തിനോ റെഗുലർ എക്സ്പ്രഷനോ വേണ്ടി ഒരു സ്ട്രിംഗ് തിരയുകയും പൊരുത്തത്തിൻ്റെ സ്ഥാനം നൽകുകയും ചെയ്യുന്നു. |
| !== | കർശനമായ അസമത്വ ഓപ്പറേറ്റർ. ഓപ്പറണ്ടുകൾ തുല്യമല്ലെങ്കിൽ കൂടാതെ/അല്ലെങ്കിൽ ഒരേ തരത്തിലുള്ളതല്ലെങ്കിൽ ശരിയാണെന്ന് നൽകുന്നു. |
JavaScript സബ്സ്ട്രിംഗ് രീതികൾ മനസ്സിലാക്കുന്നു
ഒരു സ്ട്രിംഗിൽ JavaScript-ൽ ഒരു സബ്സ്ട്രിംഗ് ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നതിനുള്ള വ്യത്യസ്ത രീതികൾ നൽകിയിരിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ ചിത്രീകരിക്കുന്നു. ആദ്യ രീതി ഉപയോഗിക്കുന്നു indexOf(), ഇത് ഒരു നിർദ്ദിഷ്ട മൂല്യത്തിൻ്റെ ആദ്യ സംഭവത്തിൻ്റെ സൂചിക നൽകുന്നു. മൂല്യം കണ്ടെത്തിയില്ലെങ്കിൽ, അത് -1 നൽകുന്നു. അടിസ്ഥാന സബ്സ്ട്രിംഗ് തിരയലുകൾക്ക് ഈ രീതി ലളിതവും ഫലപ്രദവുമാണ്. രണ്ടാമത്തെ രീതി ഉപയോഗിക്കുന്നു includes(), കൂടുതൽ ആധുനികവും വായിക്കാൻ കഴിയുന്നതുമായ ഒരു സമീപനം, സ്ട്രിംഗിൽ നിർദ്ദിഷ്ട സബ്സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ ശരിയും അല്ലാത്തപക്ഷം തെറ്റും നൽകുന്നു. ഈ രീതി കോഡ് റീഡബിലിറ്റി മെച്ചപ്പെടുത്തുന്നു, ഇത് ES6-ലും പിന്നീടുള്ള പതിപ്പുകളിലും സാധാരണയായി തിരഞ്ഞെടുക്കപ്പെടുന്നു.
മൂന്നാമത്തെ ഉദാഹരണം ഉപയോഗിക്കുന്നു RegExp() ഒരു സാധാരണ എക്‌സ്‌പ്രഷൻ ഒബ്ജക്റ്റ് സൃഷ്‌ടിക്കാനും test() പൊരുത്തങ്ങൾ പരിശോധിക്കാൻ. ഈ രീതി ശക്തവും വഴക്കമുള്ളതുമാണ്, കൂടുതൽ സങ്കീർണ്ണമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിന് അനുയോജ്യമാണ്. നാലാമത്തെ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു search(), ഇത് ഒരു നിർദ്ദിഷ്ട മൂല്യത്തിനോ റെഗുലർ എക്സ്പ്രഷനോ വേണ്ടി ഒരു സ്ട്രിംഗ് തിരയുകയും പൊരുത്തത്തിൻ്റെ സ്ഥാനം നൽകുകയും ചെയ്യുന്നു. ഇഷ്ടപ്പെടുക indexOf(), മൂല്യം കണ്ടെത്തിയില്ലെങ്കിൽ അത് -1 നൽകുന്നു. ഈ രീതികൾ ഒന്നിച്ച്, JavaScript-ൽ സബ്സ്ട്രിംഗ് തിരയലുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സമഗ്ര ടൂൾകിറ്റ് നൽകുന്നു, ഓരോന്നിനും പ്രത്യേക ഉപയോഗ സാഹചര്യത്തെ ആശ്രയിച്ച് അതിൻ്റെ ഗുണങ്ങളുണ്ട്.
JavaScript-ൽ സബ്സ്ട്രിംഗ് സാന്നിധ്യം പരിശോധിക്കുന്നതിനുള്ള വ്യത്യസ്ത രീതികൾ
IndexOf Method ഉപയോഗിച്ചുള്ള JavaScript ഉദാഹരണം
// Using the indexOf() methodfunction containsSubstring(mainStr, subStr) {return mainStr.indexOf(subStr) !== -1;}// Example usageconsole.log(containsSubstring("Hello, world!", "world")); // trueconsole.log(containsSubstring("Hello, world!", "JavaScript")); // false
ജാവാസ്ക്രിപ്റ്റിലെ സബ്‌സ്‌ട്രിംഗുകൾ തിരിച്ചറിയാനുള്ള വിവിധ വഴികൾ
ജാവാസ്ക്രിപ്റ്റ് ഉദാഹരണം ഉപയോഗിക്കുന്നത് രീതി ഉൾപ്പെടുന്നു
// Using the includes() methodfunction containsSubstring(mainStr, subStr) {return mainStr.includes(subStr);}// Example usageconsole.log(containsSubstring("Hello, world!", "world")); // trueconsole.log(containsSubstring("Hello, world!", "JavaScript")); // false
JavaScript-ലെ സബ്‌സ്‌ട്രിംഗുകൾ ഫലപ്രദമായി തിരിച്ചറിയുന്നു
റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്ന ജാവാസ്ക്രിപ്റ്റ് ഉദാഹരണം
// Using a Regular Expressionfunction containsSubstring(mainStr, subStr) {const regex = new RegExp(subStr);return regex.test(mainStr);}// Example usageconsole.log(containsSubstring("Hello, world!", "world")); // trueconsole.log(containsSubstring("Hello, world!", "JavaScript")); // false
JavaScript-ൽ സബ്‌സ്‌ട്രിംഗുകൾക്കായി പരിശോധിക്കുന്നു
തിരയൽ രീതി ഉപയോഗിച്ച് JavaScript ഉദാഹരണം
// Using the search() methodfunction containsSubstring(mainStr, subStr) {return mainStr.search(subStr) !== -1;}// Example usageconsole.log(containsSubstring("Hello, world!", "world")); // trueconsole.log(containsSubstring("Hello, world!", "JavaScript")); // false
JavaScript-ൽ സബ്സ്ട്രിംഗ് തിരയലിനുള്ള ഇതര രീതികൾ
JavaScript-ൽ സബ്‌സ്‌ട്രിംഗുകൾ പരിശോധിക്കുമ്പോൾ പരിഗണിക്കേണ്ട മറ്റൊരു വശം പ്രകടനമാണ്. വലിയ സ്ട്രിംഗുകൾക്കോ പതിവ് പരിശോധനകൾക്കോ, കാര്യക്ഷമമായ ഒരു രീതി തിരഞ്ഞെടുക്കുന്നത് പ്രധാനമാണ്. ദി includes() ES6-ൽ അവതരിപ്പിച്ച രീതി, പഴയ രീതികളേക്കാൾ വേഗമേറിയതും കൂടുതൽ വായിക്കാവുന്നതുമാണ് indexOf(). എന്നിരുന്നാലും, കൂടുതൽ സങ്കീർണ്ണമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിനായി, പതിവ് എക്സ്പ്രഷനുകൾ സൃഷ്ടിച്ചു RegExp() മന്ദഗതിയിലാകാൻ സാധ്യതയുണ്ടെങ്കിലും വളരെ ശക്തമായിരിക്കും.
പ്രകടനത്തിന് പുറമേ, ഉപയോഗത്തിൻ്റെ എളുപ്പവും വായനാക്ഷമതയും പ്രധാനമാണ്. ദി includes() രീതി കൂടുതൽ അവബോധജന്യവും ലളിതവുമാണ്, കോഡ് മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു. കൂടെ പതിവ് പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കുന്നു RegExp() ഒപ്പം test() വിപുലമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ കഴിവുകൾ നൽകുന്നു, ഇത് കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ ഉപയോഗപ്രദമാണ്. ഈ വ്യത്യസ്ത രീതികളും അവയുടെ ട്രേഡ്-ഓഫുകളും മനസ്സിലാക്കുന്നത് കാര്യക്ഷമവും പരിപാലിക്കാവുന്നതുമായ ജാവാസ്ക്രിപ്റ്റ് കോഡ് എഴുതുന്നതിന് പ്രധാനമാണ്.
JavaScript-ലെ സബ്സ്ട്രിംഗ് തിരയലിനെ കുറിച്ച് പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ
- JavaScript-ൽ സബ്‌സ്‌ട്രിംഗുകൾ പരിശോധിക്കുന്നതിനുള്ള ഏറ്റവും വേഗതയേറിയ രീതി ഏതാണ്?
- ദി includes() ലളിതമായ സബ്സ്ട്രിംഗ് പരിശോധനകൾക്ക് സാധാരണയായി ഏറ്റവും വേഗതയേറിയതും വായിക്കാവുന്നതുമാണ് രീതി.
- സബ്സ്ട്രിംഗ് തിരയലുകൾക്കായി ഞാൻ എപ്പോഴാണ് പതിവ് എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കേണ്ടത്?
- ഉപയോഗിക്കുക RegExp() ഒപ്പം test() പോലുള്ള ലളിതമായ രീതികൾ കൈകാര്യം ചെയ്യാൻ കഴിയാത്ത കൂടുതൽ സങ്കീർണ്ണമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിന് includes().
- എനിക്ക് ഉപയോഗിക്കാമോ indexOf() എല്ലാ ബ്രൗസറുകളിലും സബ്സ്ട്രിംഗ് തിരയലുകൾക്കായി?
- അതെ, indexOf() എല്ലാ ബ്രൗസറുകളിലും വ്യാപകമായി പിന്തുണയ്ക്കുന്നു, ഇത് സബ്സ്ട്രിംഗ് തിരയലുകൾക്ക് വിശ്വസനീയമായ തിരഞ്ഞെടുപ്പായി മാറുന്നു.
- ആണ് includes() എല്ലാ JavaScript പതിപ്പുകളിലും ലഭ്യമാണോ?
- includes() ES6-ൽ അവതരിപ്പിച്ചു, അതിനാൽ ജാവാസ്ക്രിപ്റ്റിൻ്റെ പഴയ പതിപ്പുകളിൽ ഇത് ലഭ്യമല്ല. പഴയ പരിതസ്ഥിതികൾക്കായി, ഉപയോഗിക്കുക indexOf().
- കേസ്-ഇൻസെൻസിറ്റീവ് സബ്സ്ട്രിംഗ് തിരയലുകൾ ഞാൻ എങ്ങനെ കൈകാര്യം ചെയ്യും?
- പ്രധാന സ്‌ട്രിംഗും സബ്‌സ്‌ട്രിംഗും ഉപയോഗിച്ച് ഒരേ കേസിലേക്ക് പരിവർത്തനം ചെയ്യുക toLowerCase() അഥവാ toUpperCase() പരിശോധിക്കുന്നതിന് മുമ്പ്.
- എന്താണ് തമ്മിലുള്ള വ്യത്യാസം search() ഒപ്പം indexOf()?
- ദി search() രീതിക്ക് ഒരു സാധാരണ പദപ്രയോഗം സ്വീകരിക്കാൻ കഴിയും, അതേസമയം indexOf() ഒരു സ്ട്രിംഗ് ഉപയോഗിച്ച് മാത്രമേ പ്രവർത്തിക്കൂ.
- സാധാരണ പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കുന്നതിന് എന്തെങ്കിലും പോരായ്മകളുണ്ടോ?
- റെഗുലർ എക്സ്പ്രഷനുകൾ സാവധാനത്തിലും കൂടുതൽ സങ്കീർണ്ണവും എഴുതാനും മനസ്സിലാക്കാനും കഴിയും, അതിനാൽ കൂടുതൽ വിപുലമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിന് ആവശ്യമുള്ളപ്പോൾ അവ ഉപയോഗിക്കുക.
- സബ്സ്ട്രിംഗ് തിരയലുകൾക്കുള്ള ചില സാധാരണ ഉപയോഗ കേസുകൾ ഏതൊക്കെയാണ്?
- ഉപയോക്തൃ ഇൻപുട്ട് സാധൂകരിക്കുക, കീവേഡുകൾക്കായി തിരയുക, ടെക്സ്റ്റ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക എന്നിവ സാധാരണ ഉപയോഗ കേസുകളിൽ ഉൾപ്പെടുന്നു.
JavaScript-ൽ സബ്സ്ട്രിംഗ് തിരയൽ ടെക്നിക്കുകൾ സംഗ്രഹിക്കുന്നു
JavaScript-ൽ, ഡയറക്ട് ഇല്ലെങ്കിലും, ഒരു സ്ട്രിംഗിൽ ഒരു സബ്സ്ട്രിംഗ് ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ ഒന്നിലധികം മാർഗങ്ങളുണ്ട്. contains രീതി. പോലുള്ള രീതികൾ indexOf() ഒപ്പം includes() ലളിതമായ തിരയലുകൾക്ക് നേരായ പരിഹാരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. കൂടുതൽ സങ്കീർണ്ണമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിനായി, RegExp() ഒപ്പം test() വളരെ ഫലപ്രദമാണ്. നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതി തിരഞ്ഞെടുക്കുമ്പോൾ പ്രകടനവും വായനയും പോലുള്ള ഘടകങ്ങൾ പരിഗണിക്കേണ്ടത് പ്രധാനമാണ്.
അതേസമയം includes() കൂടുതൽ ആധുനികവും വായിക്കാവുന്നതുമാണ്, indexOf() എല്ലാ ബ്രൗസറുകളിലും വ്യാപകമായി പിന്തുണയ്ക്കുന്നു. പതിവ് എക്സ്പ്രഷനുകൾ ശക്തമായ പൊരുത്തപ്പെടുത്തൽ കഴിവുകൾ നൽകുന്നു, എന്നാൽ കൂടുതൽ സങ്കീർണ്ണവും വേഗത കുറഞ്ഞതുമാകാം. ഈ രീതികൾ മനസിലാക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് JavaScript-ലെ സബ്സ്ട്രിംഗ് തിരയൽ പ്രശ്നങ്ങൾ കാര്യക്ഷമമായി പരിഹരിക്കാൻ കഴിയും, അവരുടെ കോഡ് ശുദ്ധവും ഫലപ്രദവുമാണെന്ന് ഉറപ്പാക്കുന്നു.
JavaScript സബ്സ്ട്രിംഗ് രീതികളെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ
ഉപസംഹാരമായി, ഒരു സ്ട്രിംഗിൽ ഒരു സബ്സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ JavaScript നിരവധി ഫലപ്രദമായ മാർഗങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. ലളിതമായതിൽ നിന്ന് indexOf() ഒപ്പം includes() ശക്തരിലേക്കുള്ള രീതികൾ RegExp() ഒപ്പം test() രീതികൾ, ഡെവലപ്പർമാർക്ക് അവരുടെ പക്കലുണ്ട്. അടിസ്ഥാന സബ്സ്ട്രിംഗ് പരിശോധനകൾക്കോ സങ്കീർണ്ണമായ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിനോ ആകട്ടെ, ഓരോ രീതിക്കും അതിൻ്റേതായ ശക്തികളുണ്ട്, വ്യത്യസ്ത സാഹചര്യങ്ങൾക്ക് അനുയോജ്യമാണ്. നിങ്ങളുടെ നിർദ്ദിഷ്ട ആവശ്യങ്ങൾക്കായി ശരിയായ രീതി തിരഞ്ഞെടുക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് കാര്യക്ഷമവും പരിപാലിക്കാവുന്നതുമായ കോഡ് ഉറപ്പാക്കാൻ കഴിയും.