ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಮರ್ಥ ಅರೇ ಮೌಲ್ಯ ಪರಿಶೀಲನೆ
JavaScript ನಲ್ಲಿ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ರಚನೆಯೊಳಗೆ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನವು ಲೂಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರಣಿಯ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಅಂಶವನ್ನು ಗುರಿ ಮೌಲ್ಯಕ್ಕೆ ಹೋಲಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನವು ಮೌಖಿಕ ಮತ್ತು ನಿಷ್ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು.
ಅದೃಷ್ಟವಶಾತ್, ಈ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ನಾವು ಮ್ಯಾನ್ಯುವಲ್ ಲೂಪ್ ವಿಧಾನಕ್ಕೆ ಉತ್ತಮ ಪರ್ಯಾಯಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಈ ವಿಧಾನಗಳು ನಿಮಗೆ ಕ್ಲೀನರ್ ಮತ್ತು ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆಯ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| Array.prototype.includes | ಒಂದು ಶ್ರೇಣಿಯು ಅದರ ನಮೂದುಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಸರಿ ಅಥವಾ ತಪ್ಪನ್ನು ಸೂಕ್ತವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
| Array.prototype.indexOf | ರಚನೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದಾದ ಮೊದಲ ಸೂಚ್ಯಂಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಅದು ಇಲ್ಲದಿದ್ದರೆ -1. |
| Set.prototype.has | ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅಂಶವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಅದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
| Array.prototype.some | ಸರಣಿಯಲ್ಲಿನ ಕನಿಷ್ಠ ಒಂದು ಅಂಶವು ಒದಗಿಸಿದ ಕಾರ್ಯದಿಂದ ಅಳವಡಿಸಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣವಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ಅದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
| Set | ಪ್ರಾಚೀನ ಮೌಲ್ಯಗಳು ಅಥವಾ ವಸ್ತು ಉಲ್ಲೇಖಗಳು ಯಾವುದೇ ಪ್ರಕಾರದ ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಅನುಮತಿಸುವ ಹೊಸ ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. |
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇ ಮೌಲ್ಯ ಪರಿಶೀಲನೆ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಒದಗಿಸಿದ ಉದಾಹರಣೆಗಳಲ್ಲಿ, JavaScript ರಚನೆಯು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಲು ನಾವು ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಮೊದಲ ವಿಧಾನವು ಬಳಸುತ್ತದೆ , ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅಂಶವು ರಚನೆಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಬೂಲಿಯನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಸರಳವಾಗಿದೆ, ಇದು ಸರಳ ತಪಾಸಣೆಗೆ ಅತ್ಯುತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ. ಇನ್ನೊಂದು ವಿಧಾನವು ಒಳಗೊಂಡಿರುತ್ತದೆ , ಇದು ಕಂಡುಬಂದರೆ ಅಂಶದ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ -1. ಈ ವಿಧಾನವು ಒಂದು ಅಂಶದ ಸ್ಥಾನವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಉಪಯುಕ್ತವಾಗಿದೆ ಆದರೆ ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಅದರ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸಲು ಸಹ ಬಳಸಬಹುದು.
ದೊಡ್ಡ ಸರಣಿಗಳಿಗಾಗಿ, a ಅನ್ನು ಬಳಸಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು. ರಚನೆಯನ್ನು a ಗೆ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ ಮತ್ತು ಬಳಸುವುದು , ಅಂಶವಿದೆಯೇ ಎಂದು ನಾವು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು. ದಿ Array.prototype.some ವಿಧಾನವು ಮತ್ತೊಂದು ES6 ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ರಚನೆಯಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ಅಂಶವು ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಕಾರ್ಯವನ್ನು ಹಾದುಹೋಗುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ಅದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಪ್ರತಿಯೊಂದು ವಿಧಾನಗಳು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿನ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ, ಅಭಿವರ್ಧಕರು ತಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾದದನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅರೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ 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')); // trueconsole.log(contains(fruits, 'grape')); // false
ಒಂದು ಶ್ರೇಣಿಯು indexOf ನೊಂದಿಗೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ 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')); // trueconsole.log(contains(vegetables, 'lettuce')); // false
ಅರೇ ಒಂದು ಸೆಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ
ಸೆಟ್ ಜೊತೆಗೆ JavaScript ES6
// Using Set for large arraysfunction contains(array, value) {const set = new Set(array);return set.has(value);}// Example usage:const items = ['pen', 'pencil', 'eraser'];console.log(contains(items, 'pencil')); // trueconsole.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')); // trueconsole.log(contains(colors, 'yellow')); // false
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಮೌಲ್ಯ ಪರಿಶೀಲನೆಗಾಗಿ ಅರೇ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ
ಒಂದು ಶ್ರೇಣಿಯು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಇನ್ನೊಂದು ಅಂಶವು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ವಿಧಾನ. ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಕಾರ್ಯವನ್ನು ಪೂರೈಸುವ ರಚನೆಯಲ್ಲಿನ ಮೊದಲ ಅಂಶವನ್ನು ಈ ವಿಧಾನವು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಭಿನ್ನವಾಗಿ ಅಥವಾ , find ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ವಸ್ತುಗಳ ಸರಣಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ದಿ ವಿಧಾನವು ಅದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದರೆ ಅಂಶದ ಬದಲಿಗೆ ಪರೀಕ್ಷಾ ಕಾರ್ಯವನ್ನು ತೃಪ್ತಿಪಡಿಸುವ ಮೊದಲ ಅಂಶದ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ರಚನೆಯೊಳಗಿನ ಮೌಲ್ಯದ ಸ್ಥಾನವನ್ನು ಗುರುತಿಸಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳಲ್ಲಿ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಹುಡುಕಾಟಗಳು ಮತ್ತು ಷರತ್ತುಗಳಿಗಾಗಿ ಎರಡೂ ವಿಧಾನಗಳು ವರ್ಧಿತ ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತವೆ.
- ಹೇಗೆ ಮಾಡುತ್ತದೆ ವಿಧಾನ ಕೆಲಸ?
- ದಿ ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅಂಶವಿದೆಯೇ ಎಂದು ವಿಧಾನ ಪರಿಶೀಲಿಸುತ್ತದೆ, ಅದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- ಎರಡರ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು ಮತ್ತು ?
- ಅಂಶದ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಹಾಗೆಯೇ ಅದರ ಉಪಸ್ಥಿತಿಯನ್ನು ಸೂಚಿಸುವ ಬೂಲಿಯನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- ನಾನು ಯಾವಾಗ ಬಳಸಬೇಕು ವಿಧಾನ?
- ಬಳಸಿ ರಚನೆಯೊಳಗೆ ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವ ಮೊದಲ ಅಂಶವನ್ನು ನೀವು ಪತ್ತೆ ಮಾಡಬೇಕಾದಾಗ.
- ಏನು ಮಾಡುತ್ತದೆ ಮಾಡುವುದೇ?
- ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಕಾರ್ಯವನ್ನು ಪೂರೈಸುವ ಮೊದಲ ಅಂಶದ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- ಹೇಗೆ ವ್ಯೂಹದ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಲು ವಸ್ತುಗಳು ಸಹಾಯ ಮಾಡುತ್ತವೆಯೇ?
- ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅನನ್ಯ ಅಂಶಗಳ ತ್ವರಿತ ವೀಕ್ಷಣೆಗೆ ಅವಕಾಶ ನೀಡುತ್ತವೆ, ದೊಡ್ಡ ಸರಣಿಗಳಲ್ಲಿನ ಮೌಲ್ಯಗಳ ಉಪಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಅವುಗಳನ್ನು ಸಮರ್ಥವಾಗಿಸುತ್ತದೆ.
- ಮಾಡಬಹುದು ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಲು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದೇ?
- ಹೌದು, ದಿ ವ್ಯೂಹದಲ್ಲಿನ ಕನಿಷ್ಠ ಒಂದು ಅಂಶವು ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಕಾರ್ಯವನ್ನು ಹಾದುಹೋಗುತ್ತದೆಯೇ ಅಥವಾ ಸರಿ ಅಥವಾ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆಯೇ ಎಂದು ವಿಧಾನ ಪರೀಕ್ಷಿಸುತ್ತದೆ.
- ದೊಡ್ಡ ಅರೇಗಳಿಗೆ ಯಾವ ವಿಧಾನವು ಉತ್ತಮವಾಗಿದೆ?
- ಎ ಅನ್ನು ಬಳಸುವುದು ಅದರ ಆಪ್ಟಿಮೈಸ್ಡ್ ಲುಕಪ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರಣದಿಂದಾಗಿ ದೊಡ್ಡ ಅರೇಗಳು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು.
- ಬಳಕೆಯ ಅನುಕೂಲಗಳು ಯಾವುವು ಮತ್ತು ?
- ಅವರು ಸಂಕೀರ್ಣ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಹೆಚ್ಚು ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತಾರೆ ಮತ್ತು ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಫಲಿತಾಂಶಗಳನ್ನು (ಅಂಶ ಅಥವಾ ಸೂಚ್ಯಂಕ) ಹಿಂತಿರುಗಿಸುತ್ತಾರೆ ಮತ್ತು .
ಅರೇ ಮೌಲ್ಯ ಪರಿಶೀಲನೆಯ ಒಳನೋಟಗಳನ್ನು ಮುಕ್ತಾಯಗೊಳಿಸಲಾಗುತ್ತಿದೆ
ಕೊನೆಯಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಹಲವು ರೀತಿಯಲ್ಲಿ ಸಂಪರ್ಕಿಸಬಹುದು, ಪ್ರತಿಯೊಂದೂ ಅದರ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ. ದಿ ವಿಧಾನವು ಸರಳ ತಪಾಸಣೆಗಾಗಿ ನೇರ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಹುಡುಕಾಟಗಳಿಗಾಗಿ, ದಿ ಮತ್ತು ವಿಧಾನಗಳು ವರ್ಧಿತ ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಬಳಸಿಕೊಳ್ಳುತ್ತಿದೆ Set ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು. ಸಂದರ್ಭದ ಆಧಾರದ ಮೇಲೆ ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಆರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಕ್ಲೀನರ್ ಮತ್ತು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು.