ഒരു JavaScript അറേയിൽ ഒരു

Lucas Simon

2024, ജൂൺ 8, ശനിയാഴ്‌ച 5:30:58 PM

JavaScript-ൽ കാര്യക്ഷമമായ അറേ മൂല്യ പരിശോധന
ജാവാസ്ക്രിപ്റ്റിലെ അറേകളിൽ പ്രവർത്തിക്കുമ്പോൾ, അറേയിൽ ഒരു പ്രത്യേക മൂല്യം നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കേണ്ടത് സാധാരണമാണ്. ഒരു ലൂപ്പ് ഉപയോഗിച്ച് അറേയിലൂടെ ആവർത്തിച്ച് ഓരോ ഘടകത്തെയും ടാർഗെറ്റ് മൂല്യവുമായി താരതമ്യം ചെയ്യുന്നതാണ് പരമ്പരാഗത രീതി. എന്നിരുന്നാലും, ഈ സമീപനം വാചാലവും കാര്യക്ഷമമല്ലാത്തതുമാകാം.
ഭാഗ്യവശാൽ, ജാവാസ്ക്രിപ്റ്റ് ഈ ടാസ്ക്ക് പൂർത്തിയാക്കാൻ കൂടുതൽ സംക്ഷിപ്തവും കാര്യക്ഷമവുമായ വഴികൾ നൽകുന്നു. ഈ ലേഖനത്തിൽ, ഒരു അറേയിൽ ഒരു നിർദ്ദിഷ്‌ട മൂല്യം ഉൾപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നതിനുള്ള മാനുവൽ ലൂപ്പ് രീതിക്ക് മികച്ച ബദലുകൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. വൃത്തിയുള്ളതും കൂടുതൽ കാര്യക്ഷമവുമായ കോഡ് എഴുതാൻ ഈ രീതികൾ നിങ്ങളെ സഹായിക്കും.

കമാൻഡ് വിവരണം

Array.prototype.includes ഒരു അറേയിൽ അതിൻ്റെ എൻട്രികൾക്കിടയിൽ ഒരു നിശ്ചിത മൂല്യം ഉൾപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു, അത് ശരിയാണോ തെറ്റാണോ എന്ന് നൽകുന്നു.

Array.prototype.indexOf അറേയിൽ നൽകിയിരിക്കുന്ന ഘടകം കണ്ടെത്താനാകുന്ന ആദ്യ സൂചിക നൽകുന്നു, അല്ലെങ്കിൽ അത് നിലവിലില്ലെങ്കിൽ -1.

Set.prototype.has ഒരു സെറ്റ് ഒബ്‌ജക്‌റ്റിൽ ഒരു നിർദ്ദിഷ്‌ട ഘടകം അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു, ശരിയോ തെറ്റോ നൽകുന്നു.

Array.prototype.some നൽകിയിരിക്കുന്ന ഫംഗ്‌ഷൻ നടപ്പിലാക്കിയ ടെസ്റ്റിൽ അറേയിലെ ഒരു ഘടകമെങ്കിലും വിജയിക്കുമോ എന്ന് പരിശോധിക്കുന്നു, ശരിയാണോ തെറ്റാണോ എന്ന് നൽകുന്നു.

Set പ്രാകൃത മൂല്യങ്ങളോ ഒബ്ജക്റ്റ് റഫറൻസുകളോ ആകട്ടെ, ഏത് തരത്തിലുമുള്ള അദ്വിതീയ മൂല്യങ്ങൾ സംഭരിക്കുന്നതിന് അനുവദിക്കുന്ന ഒരു പുതിയ സെറ്റ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു.

കമാൻഡ്	വിവരണം
Array.prototype.includes	ഒരു അറേയിൽ അതിൻ്റെ എൻട്രികൾക്കിടയിൽ ഒരു നിശ്ചിത മൂല്യം ഉൾപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു, അത് ശരിയാണോ തെറ്റാണോ എന്ന് നൽകുന്നു.
Array.prototype.indexOf	അറേയിൽ നൽകിയിരിക്കുന്ന ഘടകം കണ്ടെത്താനാകുന്ന ആദ്യ സൂചിക നൽകുന്നു, അല്ലെങ്കിൽ അത് നിലവിലില്ലെങ്കിൽ -1.
Set.prototype.has	ഒരു സെറ്റ് ഒബ്‌ജക്‌റ്റിൽ ഒരു നിർദ്ദിഷ്‌ട ഘടകം അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു, ശരിയോ തെറ്റോ നൽകുന്നു.
Array.prototype.some	നൽകിയിരിക്കുന്ന ഫംഗ്‌ഷൻ നടപ്പിലാക്കിയ ടെസ്റ്റിൽ അറേയിലെ ഒരു ഘടകമെങ്കിലും വിജയിക്കുമോ എന്ന് പരിശോധിക്കുന്നു, ശരിയാണോ തെറ്റാണോ എന്ന് നൽകുന്നു.
Set	പ്രാകൃത മൂല്യങ്ങളോ ഒബ്ജക്റ്റ് റഫറൻസുകളോ ആകട്ടെ, ഏത് തരത്തിലുമുള്ള അദ്വിതീയ മൂല്യങ്ങൾ സംഭരിക്കുന്നതിന് അനുവദിക്കുന്ന ഒരു പുതിയ സെറ്റ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റിൽ അറേ മൂല്യ പരിശോധന രീതികൾ മനസ്സിലാക്കുന്നു

നൽകിയിരിക്കുന്ന ഉദാഹരണങ്ങളിൽ, ഒരു JavaScript അറേയിൽ ഒരു നിർദ്ദിഷ്‌ട മൂല്യമുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ ഞങ്ങൾ നിരവധി രീതികൾ പര്യവേക്ഷണം ചെയ്തു. ആദ്യ രീതി ഉപയോഗിക്കുന്നു , ഇത് അറേയിൽ നിർദ്ദിഷ്ട ഘടകം നിലവിലുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു. ഈ രീതി സംക്ഷിപ്തവും ലളിതവുമാണ്, ഇത് ലളിതമായ പരിശോധനകൾക്ക് മികച്ച തിരഞ്ഞെടുപ്പാണ്. മറ്റൊരു രീതി ഉൾപ്പെടുന്നു , അത് കണ്ടെത്തിയാൽ മൂലകത്തിൻ്റെ സൂചിക നൽകുന്നു, അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ -1. ഒരു മൂലകത്തിൻ്റെ സ്ഥാനം കണ്ടെത്തുന്നതിന് ഈ രീതി ഉപയോഗപ്രദമാണ്, എന്നാൽ റിട്ടേൺ മൂല്യം പരിശോധിച്ച് അതിൻ്റെ നിലനിൽപ്പ് പരിശോധിക്കാനും ഇത് ഉപയോഗിക്കാം.

വലിയ അറേകൾക്കായി, a ഉപയോഗിക്കുന്നത് കൂടുതൽ കാര്യക്ഷമമാക്കാൻ കഴിയും. അറേയെ a ആയി പരിവർത്തനം ചെയ്യുന്നതിലൂടെ ഉപയോഗിക്കുകയും ചെയ്യുന്നു , മൂലകം ഉണ്ടോ എന്ന് നമുക്ക് പെട്ടെന്ന് പരിശോധിക്കാം. ദി Array.prototype.some മെത്തേഡ് മറ്റൊരു ES6 സവിശേഷതയാണ്, അറേയിലെ ഒരു ഘടകമെങ്കിലും നൽകിയിട്ടുള്ള ഒരു ടെസ്റ്റ് ഫംഗ്‌ഷൻ കടന്നുപോകുന്നുണ്ടോ, ശരിയാണോ തെറ്റാണോ എന്ന് പരിശോധിക്കുന്നു. ഈ രീതികളിൽ ഓരോന്നും ഒരു അറേയിലെ ഒരു മൂല്യം പരിശോധിക്കുന്നതിനുള്ള പ്രശ്നം പരിഹരിക്കുന്നതിന് വ്യത്യസ്തമായ സമീപനം വാഗ്ദാനം ചെയ്യുന്നു, ഇത് ഡെവലപ്പർമാർക്ക് അവരുടെ നിർദ്ദിഷ്ട ആവശ്യങ്ങളെ അടിസ്ഥാനമാക്കി ഏറ്റവും അനുയോജ്യമായ ഒന്ന് തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്നു.

ആധുനിക ജാവാസ്ക്രിപ്റ്റ് രീതികൾ ഉപയോഗിച്ച് ഒരു അറേയിൽ ഒരു മൂല്യം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു

JavaScript ES6

// Using Array.prototype.includes method (ES6)
function contains(array, value) {
    return array.includes(value);
}
// Example usage:
const fruits = ['apple', 'banana', 'mango'];
console.log(contains(fruits, 'banana')); // true
console.log(contains(fruits, 'grape')); // false

ഒരു അറേയിൽ indexOf ഉള്ള ഒരു മൂല്യം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു

JavaScript ES5

// Using Array.prototype.indexOf method (ES5)
function contains(array, value) {
    return array.indexOf(value) !== -1;
}
// Example usage:
const vegetables = ['carrot', 'broccoli', 'spinach'];
console.log(contains(vegetables, 'broccoli')); // true
console.log(contains(vegetables, 'lettuce')); // false

ഒരു സെറ്റ് ഉപയോഗിച്ച് ഒരു അറേയിൽ ഒരു മൂല്യം അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു

സെറ്റിനൊപ്പം JavaScript ES6

// Using Set for large arrays
function contains(array, value) {
    const set = new Set(array);
    return set.has(value);
}
// Example usage:
const items = ['pen', 'pencil', 'eraser'];
console.log(contains(items, 'pencil')); // true
console.log(contains(items, 'marker')); // false

ചില രീതികൾ ഉപയോഗിച്ച് ഒരു അറേയിൽ ഒരു മൂല്യം അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു

Array.some ഉള്ള JavaScript ES6

// Using Array.prototype.some method (ES6)
function contains(array, value) {
    return array.some(element => element === value);
}
// Example usage:
const colors = ['red', 'green', 'blue'];
console.log(contains(colors, 'green')); // true
console.log(contains(colors, 'yellow')); // false

JavaScript-ൽ മൂല്യ പരിശോധനയ്ക്കായി അറേ രീതികൾ പര്യവേക്ഷണം ചെയ്യുന്നു

ഒരു അറേയിൽ ഒരു മൂല്യം അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നതിൻ്റെ മറ്റൊരു വശം ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു രീതി. നൽകിയിരിക്കുന്ന ടെസ്റ്റിംഗ് ഫംഗ്‌ഷൻ തൃപ്തിപ്പെടുത്തുന്ന അറേയിലെ ആദ്യ ഘടകം ഈ രീതി നൽകുന്നു. വ്യത്യസ്തമായി അഥവാ , find ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് കൂടുതൽ സങ്കീർണ്ണമായ അവസ്ഥ പരിശോധിക്കാൻ അനുവദിക്കുന്നു. ഒബ്‌ജക്‌റ്റുകളുടെ നിരകളുമായി പ്രവർത്തിക്കുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

കൂടാതെ, ദി രീതി സമാനമായി പ്രവർത്തിക്കുന്നു എന്നാൽ ഘടകത്തിന് പകരം ടെസ്റ്റിംഗ് ഫംഗ്‌ഷനെ തൃപ്തിപ്പെടുത്തുന്ന ആദ്യ മൂലകത്തിൻ്റെ സൂചിക തിരികെ നൽകുന്നു. അറേയ്ക്കുള്ളിലെ ഒരു മൂല്യത്തിൻ്റെ സ്ഥാനം കൃത്യമായി നിർണ്ണയിക്കാൻ ഇത് സഹായിക്കും. ജാവാസ്ക്രിപ്റ്റ് അറേകളിലെ കൂടുതൽ സങ്കീർണ്ണമായ തിരയലുകൾക്കും വ്യവസ്ഥകൾക്കും രണ്ട് രീതികളും മെച്ചപ്പെടുത്തിയ ഫ്ലെക്സിബിലിറ്റി വാഗ്ദാനം ചെയ്യുന്നു.

എങ്ങനെ ചെയ്യുന്നു രീതി വർക്ക്?
ദി ഒരു അറേയിൽ ഒരു നിർദ്ദിഷ്‌ട ഘടകം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു, ശരിയോ തെറ്റോ നൽകുന്നു.
എന്താണ് തമ്മിലുള്ള വ്യത്യാസം ഒപ്പം ?
മൂലകത്തിൻ്റെ സൂചിക തിരികെ നൽകുന്നു, അതേസമയം അതിൻ്റെ സാന്നിധ്യം സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.
ഞാൻ എപ്പോഴാണ് ഉപയോഗിക്കേണ്ടത് രീതി?
ഉപയോഗിക്കുക ഒരു അറേയ്ക്കുള്ളിൽ ഒരു നിർദ്ദിഷ്ട വ്യവസ്ഥ പാലിക്കുന്ന ആദ്യ ഘടകം നിങ്ങൾ കണ്ടെത്തേണ്ടിവരുമ്പോൾ.
എന്താണ് ചെയ്യുന്നത് ചെയ്യണോ?
നൽകിയിരിക്കുന്ന ടെസ്റ്റിംഗ് ഫംഗ്‌ഷൻ തൃപ്തിപ്പെടുത്തുന്ന ആദ്യ ഘടകത്തിൻ്റെ സൂചിക നൽകുന്നു.
എങ്ങനെ ചെയ്യും അറേ മൂല്യം പരിശോധിക്കാൻ ഒബ്‌ജക്‌റ്റുകൾ സഹായിക്കുമോ?
ഒബ്‌ജക്‌റ്റുകൾ അദ്വിതീയ ഘടകങ്ങളെ വേഗത്തിൽ തിരയാൻ അനുവദിക്കുന്നു, വലിയ അറേകളിലെ മൂല്യങ്ങളുടെ സാന്നിധ്യം പരിശോധിക്കുന്നതിന് അവയെ കാര്യക്ഷമമാക്കുന്നു.
കഴിയും മൂല്യ പരിശോധനയ്ക്ക് ഉപയോഗിക്കുന്ന രീതി?
അതെ, ദി അറേയിലെ ഒരു ഘടകമെങ്കിലും നൽകിയിട്ടുള്ള ഒരു ടെസ്റ്റ് ഫംഗ്‌ഷൻ കടന്നുപോകുന്നുണ്ടോ, ശരിയാണോ തെറ്റാണോ എന്ന് മെത്തേഡ് പരിശോധിക്കുന്നു.
വലിയ അറേകൾക്ക് ഏത് രീതിയാണ് നല്ലത്?
എ ഉപയോഗിക്കുന്നത് ഒപ്റ്റിമൈസ് ചെയ്ത ലുക്കപ്പ് പ്രവർത്തനങ്ങൾ കാരണം വലിയ അറേകൾക്ക് കൂടുതൽ കാര്യക്ഷമമാകും.
ഉപയോഗിക്കുന്നതിൻ്റെ ഗുണങ്ങൾ എന്തൊക്കെയാണ് ഒപ്പം ?
അവ സങ്കീർണ്ണമായ അവസ്ഥകൾക്ക് കൂടുതൽ വഴക്കം നൽകുകയും താരതമ്യപ്പെടുത്തുമ്പോൾ കൂടുതൽ നിർദ്ദിഷ്ട ഫലങ്ങൾ (ഘടകം അല്ലെങ്കിൽ സൂചിക) നൽകുകയും ചെയ്യുന്നു ഒപ്പം .

അറേ മൂല്യ പരിശോധനയെക്കുറിച്ചുള്ള ഇൻസൈറ്റുകൾ സമാപിക്കുന്നു

ഉപസംഹാരമായി, ഒരു അറേയിൽ ജാവാസ്ക്രിപ്റ്റിൽ ഒരു പ്രത്യേക മൂല്യം ഉണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നത് ഒന്നിലധികം രീതികളിൽ സമീപിക്കാം, ഓരോന്നിനും അതിൻ്റെ ശക്തികൾ. ദി ലളിതമായ പരിശോധനകൾക്കായി രീതി ലളിതവും കാര്യക്ഷമവുമായ പരിഹാരം വാഗ്ദാനം ചെയ്യുന്നു. കൂടുതൽ സങ്കീർണ്ണമായ തിരയലുകൾക്കായി, ദി ഒപ്പം രീതികൾ മെച്ചപ്പെട്ട വഴക്കം നൽകുന്നു. ഉപയോഗപ്പെടുത്തുന്നു Set ഒബ്‌ജക്റ്റുകൾക്ക് വലിയ ഡാറ്റാസെറ്റുകളുടെ പ്രകടനം ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും. സന്ദർഭത്തെ അടിസ്ഥാനമാക്കി ഉചിതമായ രീതി തിരഞ്ഞെടുക്കുന്നതിലൂടെ, ഡവലപ്പർമാർക്ക് വൃത്തിയുള്ളതും കൂടുതൽ കാര്യക്ഷമവുമായ കോഡ് എഴുതാൻ കഴിയും.

ഒരു JavaScript അറേയിൽ ഒരു മൂല്യമുണ്ടോ എന്ന് പരിശോധിക്കുന്നതിനുള്ള ഗൈഡ്