ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇ ವಿಶಿಷ್ಟತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯು ವಿಶಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿರುತ್ತದೆ. ಇದನ್ನು ಸಾಧಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿದ್ದರೂ, ಸೊನ್ನೆಗಳ ಉಪಸ್ಥಿತಿಯಂತಹ ನಿರ್ದಿಷ್ಟ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಕೆಲವು ವಿಧಾನಗಳು ವಿಫಲವಾಗಬಹುದು.
ಈ ಲೇಖನದಲ್ಲಿ, ರಚನೆಯಿಂದ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ನಾವು ಮೂಲಮಾದರಿಯ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ನಾವು ಶೂನ್ಯ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹೊಂದಿರುವ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಪರಿಹಾರದೊಂದಿಗೆ ಹೋಲಿಸುತ್ತೇವೆ. ಈ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇ ಅನನ್ಯತೆಯನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನೀವು ಕಲಿಯುವಿರಿ.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| new Set() | ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ಯಾವುದೇ ಪ್ರಕಾರದ ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. |
| [...new Set(array)] | ಒಂದು ಸೆಟ್ ಅನ್ನು ಅನನ್ಯ ಮೌಲ್ಯಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿ ಪರಿವರ್ತಿಸಲು ಸ್ಪ್ರೆಡ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. |
| Array.prototype.getUnique | ರಚನೆಯಿಂದ ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊರತೆಗೆಯಲು ಅರೇ ಮೂಲಮಾದರಿಯಲ್ಲಿ ಹೊಸ ವಿಧಾನವನ್ನು ವಿವರಿಸುತ್ತದೆ. |
| uniqueElements[this[i]] = this[i] | ಅನನ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ವಸ್ತುವಿನಲ್ಲಿ ಕೀಲಿಯಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. |
| for (let key in uniqueElements) | ಫಲಿತಾಂಶ ರಚನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಅನನ್ಯ ಎಲಿಮೆಂಟ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ನ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. |
| const uniqueElements = {} | ಅನನ್ಯ ಅಂಶಗಳನ್ನು ಕೀಲಿಗಳಾಗಿ ಸಂಗ್ರಹಿಸಲು ಖಾಲಿ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. |
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳಲ್ಲಿ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಹೇಗೆ
ನಾವು ಪ್ರಸ್ತುತಪಡಿಸಿದ ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ new Set() ರಚನೆಯ ಅನನ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು JavaScript ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್. ಎ Set ಪ್ರತಿ ಮೌಲ್ಯವು ಅನನ್ಯವಾಗಿರಬೇಕು ಅಲ್ಲಿ ಮೌಲ್ಯಗಳ ಸಂಗ್ರಹವಾಗಿದೆ. a ಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ Set, ನಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತೇವೆ. ಪರಿವರ್ತಿಸಲು Set ಒಂದು ಶ್ರೇಣಿಗೆ ಹಿಂತಿರುಗಿ, ನಾವು ಸ್ಪ್ರೆಡ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ [...new Set(array)]. ಈ ವಿಧಾನವು ಸಂಕ್ಷಿಪ್ತವಾಗಿದೆ ಮತ್ತು ಅಪೇಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಾಧಿಸಲು JavaScript ನ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ನೀವು ಸೊನ್ನೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ನಕಲಿ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಸರಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ [1, 2, 2, 3, 4, 4, 5, 0, 0], ಕಾರ್ಯ getUniqueValues(array) ಅನನ್ಯ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಸರಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: [1, 2, 3, 4, 5, 0]. ಈ ವಿಧಾನವು ಸರಳವಾಗಿದೆ ಮತ್ತು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಸೊನ್ನೆಗಳು ಸೇರಿದಂತೆ ಎಲ್ಲಾ ರೀತಿಯ ಅಂಶಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.
ವಿಶಿಷ್ಟ ಅರೇ ಮೌಲ್ಯಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಕಸ್ಟಮ್ ವಿಧಾನ
ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಕಸ್ಟಮ್ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ Array.prototype ಎಂದು ಕರೆದರು getUnique. ಈ ವಿಧಾನವು ಅನನ್ಯ ಅಂಶಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ವಸ್ತುವನ್ನು ಬಳಸುತ್ತದೆ. ವಿಧಾನದೊಳಗೆ, ನಾವು ಮೊದಲು ಖಾಲಿ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ const uniqueElements = {} ಮತ್ತು ಖಾಲಿ ಅರೇ const resultArray = []. ನಂತರ ನಾವು a ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ for ಲೂಪ್, ಪ್ರತಿ ಅಂಶವನ್ನು ಕೀಲಿಯಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ uniqueElements ಎಲ್ಲಾ ಕೀಗಳು ಅನನ್ಯವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಆಬ್ಜೆಕ್ಟ್.
ಜನಸಂಖ್ಯೆಯ ನಂತರ uniqueElements ವಸ್ತು, ನಾವು ಇನ್ನೊಂದನ್ನು ಬಳಸುತ್ತೇವೆ for...in ವಸ್ತುವಿನ ಕೀಲಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಲೂಪ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿ ಅನನ್ಯ ಕೀಲಿಯನ್ನು ತಳ್ಳುತ್ತದೆ resultArray. ಅಂತಿಮವಾಗಿ, ವಿಧಾನವು ಹಿಂತಿರುಗುತ್ತದೆ resultArray, ಇದು ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುವ ಮೂಲಕ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ ಅವಲಂಬಿಸದೆ ಅನನ್ಯತೆಯನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಜಾರಿಗೊಳಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಬೋಧಪ್ರದವಾಗಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳಲ್ಲಿ ವಿಶಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು
ಸೆಟ್‌ಗಳನ್ನು ಬಳಸುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿಧಾನ
function getUniqueValues(array) {return [...new Set(array)];}// Example usage:const numbers = [1, 2, 2, 3, 4, 4, 5, 0, 0];const uniqueNumbers = getUniqueValues(numbers);console.log(uniqueNumbers);
ಕಸ್ಟಮ್ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಅರೇಯಲ್ಲಿ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಸ್ಟಮ್ ಪ್ರೊಟೊಟೈಪ್ ವಿಧಾನ
Array.prototype.getUnique = function() {const uniqueElements = {};const resultArray = [];for (let i = 0; i < this.length; i++) {uniqueElements[this[i]] = this[i];}for (let key in uniqueElements) {resultArray.push(uniqueElements[key]);}return resultArray;};// Example usage:const numbers = [1, 2, 2, 3, 4, 4, 5, 0, 0];const uniqueNumbers = numbers.getUnique();console.log(uniqueNumbers);
ಅರೇ ಡಿಡ್ಯೂಪ್ಲಿಕೇಶನ್ ಟೆಕ್ನಿಕ್ಸ್‌ಗೆ ಡೀಪ್ ಡೈವ್ ಮಾಡಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ರಚನೆಯಿಂದ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಮತ್ತೊಂದು ಪ್ರಮುಖ ತಂತ್ರವೆಂದರೆ ಇದರ ಬಳಕೆ filter ಸಂಯೋಜನೆಯೊಂದಿಗೆ ವಿಧಾನ indexOf ವಿಧಾನ. ಈ ವಿಧಾನವು ರಚನೆಯ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಮತ್ತು ಅದರ ಮೊದಲ ಸಂಭವವು ಅವುಗಳ ಪ್ರಸ್ತುತ ಸ್ಥಾನಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ. ಪ್ರತಿ ಅಂಶವು ಫಲಿತಾಂಶದ ರಚನೆಯಲ್ಲಿ ಒಮ್ಮೆ ಮಾತ್ರ ಸೇರಿಸಲ್ಪಟ್ಟಿದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪರಿಗಣಿಸಿ [1, 2, 2, 3, 4, 4, 5, 0, 0]. ಬಳಸಿಕೊಂಡು array.filter((item, index) => array.indexOf(item) === index), ನೀವು ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು. ಈ ವಿಧಾನವು ಪ್ರಸ್ತುತ ಅಂಶದ ಸೂಚ್ಯಂಕವು ಆ ಅಂಶದ ಮೊದಲ ಸಂಭವಿಸುವಿಕೆಯ ಸೂಚ್ಯಂಕವನ್ನು ಹೋಲುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಅದು ಇದ್ದರೆ, ಅಂಶವು ಅನನ್ಯವಾಗಿದೆ ಮತ್ತು ಹೊಸ ರಚನೆಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಡಿಡ್ಯೂಪ್ಲಿಕೇಶನ್ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು
- ರಚನೆಯಿಂದ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗ ಯಾವುದು?
- ಎ ಅನ್ನು ಬಳಸುವುದು Set ಇದು O(n) ನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿರುವುದರಿಂದ ಇದು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.
- ನಾನು ಬಳಸಬಹುದೇ filter ನಕಲು ತೆಗೆಯುವ ವಿಧಾನ?
- ಹೌದು, ಸಂಯೋಜನೆ filter ಜೊತೆಗೆ indexOf ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಸಾಮಾನ್ಯ ವಿಧಾನವಾಗಿದೆ.
- ಏಕೆ ಮಾಡುತ್ತದೆ prototype ವಿಧಾನ ಶೂನ್ಯದೊಂದಿಗೆ ವಿಫಲವಾಗಿದೆಯೇ?
- ಮೂಲ ಸ್ಕ್ರಿಪ್ಟ್ ಶೂನ್ಯದೊಂದಿಗೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ for (i = 0; e = this[i]; i++) ಶೂನ್ಯದಲ್ಲಿ ನಿಲ್ಲುತ್ತದೆ, ಅದನ್ನು ಸುಳ್ಳು ಎಂದು ಅರ್ಥೈಸುತ್ತದೆ.
- ಅನನ್ಯತೆಗಾಗಿ ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ವಿವಿಧ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ನಾನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು?
- ಎ ಅನ್ನು ಬಳಸುವುದು Set ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ಅನನ್ಯವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.
- ಬಳಸುವುದರಿಂದ ಏನು ಪ್ರಯೋಜನ new Set() ಇತರ ವಿಧಾನಗಳ ಮೇಲೆ?
- new Set() ಸಂಕ್ಷಿಪ್ತವಾಗಿದೆ ಮತ್ತು ಹೆಚ್ಚುವರಿ ತರ್ಕದ ಅಗತ್ಯವಿಲ್ಲದೆ ಎಲ್ಲಾ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
- ನಾನು ಎಲ್ಲಾ ಅರೇಗಳಿಗೆ ಅನನ್ಯ ವಿಧಾನವನ್ನು ಸೇರಿಸಬಹುದೇ?
- ಹೌದು, ಒಂದು ವಿಧಾನವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ Array.prototype, ನೀವು ಅದನ್ನು ಎಲ್ಲಾ ಅರೇಗಳಿಗೆ ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡಬಹುದು.
- ಮಾರ್ಪಡಿಸುವ ತೊಂದರೆ ಏನು Array.prototype?
- ಮಾರ್ಪಡಿಸುವುದು Array.prototype ಇತರ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸಹ ಅದನ್ನು ಮಾರ್ಪಡಿಸಿದರೆ ಸಂಘರ್ಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
- ಮೂಲ ಶ್ರೇಣಿಯನ್ನು ಬದಲಾಯಿಸದೆ ಅನನ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಒಂದು ಮಾರ್ಗವಿದೆಯೇ?
- ಹೌದು, ಅಂತಹ ವಿಧಾನಗಳು new Set() ಮತ್ತು filter ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿ, ಮೂಲವನ್ನು ಸಂರಕ್ಷಿಸಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಡಿಡಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಂತಿಮ ಆಲೋಚನೆಗಳು
ಅರೇಗಳಿಂದ ನಕಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ವಿಭಿನ್ನ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಬಳಸುತ್ತಿರಲಿ Set ಸರಳತೆ ಮತ್ತು ದಕ್ಷತೆ ಅಥವಾ ಆಳವಾದ ತಿಳುವಳಿಕೆಗಾಗಿ ಕಸ್ಟಮ್ ವಿಧಾನಗಳಿಗಾಗಿ, ಈ ವಿಧಾನಗಳನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದು ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೌಶಲ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಶೂನ್ಯ ಮೌಲ್ಯಗಳಂತಹ ವಿಶೇಷ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ನಿಮ್ಮ ಪರಿಹಾರಗಳಲ್ಲಿ ದೃಢತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.