ಪ್ರತಿಯೊಬ್ಬ ಡೆವಲಪರ್ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಅರೇ ಮೆಥಡ್‌ಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳು ಮೂಲಭೂತ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳಾಗಿವೆ, ಮತ್ತು ಸಮರ್ಥ ಮತ್ತು ಸುಂದರವಾದ ಕೋಡ್‌ಗಾಗಿ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಈ ಮೆಥಡ್‌ಗಳು ನಿಮಗೆ ಅರೇಗಳಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು, ರೂಪಾಂತರಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ನಿಮ್ಮ ಸಮಯವನ್ನು ಉಳಿಸುತ್ತವೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತವೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು ಪ್ರತಿಯೊಬ್ಬ ಡೆವಲಪರ್ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಅತ್ಯಂತ ಅಗತ್ಯವಾದ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳೊಂದಿಗೆ ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಏಕೆ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬೇಕು?

• ದಕ್ಷತೆ: ಅರೇ ಮೆಥಡ್‌ಗಳು ಅರೇಗಳ ಮೇಲೆ ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.
• ಓದುವಿಕೆ: ಅಂತರ್ನಿರ್ಮಿತ ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ.
• ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಅನೇಕ ಅರೇ ಮೆಥಡ್‌ಗಳು ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತವೆ, ಇದು ಸ್ವಚ್ಛ ಮತ್ತು ಹೆಚ್ಚು ಪರೀಕ್ಷಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ಕ್ರಾಸ್-ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಮೆಥಡ್‌ಗಳು ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳಾದ್ಯಂತ ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ.

ಅಗತ್ಯ ಅರೇ ಮೆಥಡ್‌ಗಳು

1. ಅರೇಗಳ ಮೂಲಕ ಇಟರೇಟಿಂಗ್: forEach()

forEach() ಮೆಥಡ್ ಒಂದು ಅರೇಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಎಲಿಮೆಂಟ್‌ಗೆ ಒಮ್ಮೆ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡಲು ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಸರಳವಾದ ಮಾರ್ಗವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

array.forEach(function(currentValue, index, array) {
  // ಪ್ರತಿ ಎಲಿಮೆಂಟ್‌ಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್
});

ಉದಾಹರಣೆ:

const numbers = [1, 2, 3, 4, 5];
numbers.forEach(number => {
  console.log(number * 2);
});
// ಔಟ್‌ಪುಟ್: 2, 4, 6, 8, 10

ಬಳಕೆಯ ಪ್ರಕರಣ: ಪಟ್ಟಿಯಲ್ಲಿ ಐಟಂಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವುದು, ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡುವುದು.

2. ಅರೇಗಳನ್ನು ರೂಪಾಂತರಿಸುವುದು: map()

map() ಮೆಥಡ್, ಕಾಲ್ ಮಾಡುವ ಅರೇಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಎಲಿಮೆಂಟ್‌ನ ಮೇಲೆ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದರ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಒಂದು ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ಒಂದು ಫಾರ್ಮ್ಯಾಟ್‌ನಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ರೂಪಾಂತರಿಸಲು ಇದು ಅತ್ಯುತ್ತಮವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

const newArray = array.map(function(currentValue, index, array) {
  // ರೂಪಾಂತರಿತ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿ
});

ಉದಾಹರಣೆ:

const numbers = [1, 2, 3, 4, 5];
const squaredNumbers = numbers.map(number => number * number);
console.log(squaredNumbers);
// ಔಟ್‌ಪುಟ್: [1, 4, 9, 16, 25]

ಬಳಕೆಯ ಪ್ರಕರಣ: ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಡೇಟಾವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು, ಯೂನಿಟ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು, ಮಾರ್ಪಡಿಸಿದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸುವುದು.

ಜಾಗತಿಕ ಉದಾಹರಣೆ: ನೀವು USD ಯಲ್ಲಿ ಕರೆನ್ಸಿ ಮೌಲ್ಯಗಳ ಅರೇಯನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸಿ, ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು EUR ಗೆ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ. EUR ಮೌಲ್ಯಗಳ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸಲು ನೀವು ಎಕ್ಸ್‌ಚೇಂಜ್ ರೇಟ್ API ಯೊಂದಿಗೆ map() ಅನ್ನು ಬಳಸಬಹುದು.

3. ಅರೇಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು: filter()

filter() ಮೆಥಡ್ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾದ ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಒಂದು ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸುತ್ತದೆ. ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಅರೇಯಿಂದ ನಿರ್ದಿಷ್ಟ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಇದು ಪರಿಪೂರ್ಣವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

const newArray = array.filter(function(currentValue, index, array) {
  // ಎಲಿಮೆಂಟ್ ಅನ್ನು ಉಳಿಸಲು true, ಹೊರಗಿಡಲು false ಹಿಂತಿರುಗಿಸಿ
});

ಉದಾಹರಣೆ:

const numbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = numbers.filter(number => number % 2 === 0);
console.log(evenNumbers);
// ಔಟ್‌ಪುಟ್: [2, 4, 6]

ಬಳಕೆಯ ಪ್ರಕರಣ: ಅನಗತ್ಯ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುವುದು, ಹುಡುಕಾಟ ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ಐಟಂಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು, ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು.

ಜಾಗತಿಕ ಉದಾಹರಣೆ: ವಿವಿಧ ದೇಶಗಳ ಬಳಕೆದಾರರ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇಯನ್ನು ಪರಿಗಣಿಸಿ. "Japan" ಅಥವಾ "Brazil" ನಂತಹ ನಿರ್ದಿಷ್ಟ ದೇಶದ ಬಳಕೆದಾರರನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸಲು ನೀವು filter() ಅನ್ನು ಬಳಸಬಹುದು.

4. ಅರೇಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು: reduce()

reduce() ಮೆಥಡ್ ಅರೇಯ ಪ್ರತಿಯೊಂದು ಎಲಿಮೆಂಟ್‌ನ ಮೇಲೆ (ನೀವು ಒದಗಿಸುವ) ರಿಡ್ಯೂಸರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಒಂದೇ ಔಟ್‌ಪುಟ್ ಮೌಲ್ಯ ದೊರೆಯುತ್ತದೆ. ಅರೇ ಡೇಟಾದ ಮೇಲೆ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಪ್ರಬಲವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

const result = array.reduce(function(accumulator, currentValue, currentIndex, array) {
  // ಅಪ್‌ಡೇಟ್ ಮಾಡಿದ ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ
}, initialValue);

ಉದಾಹರಣೆ:

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum);
// ಔಟ್‌ಪುಟ್: 15

ಬಳಕೆಯ ಪ್ರಕರಣ: ಮೊತ್ತ, ಸರಾಸರಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ಗರಿಷ್ಠ ಅಥವಾ ಕನಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು, ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಜೋಡಿಸುವುದು.

ಜಾಗತಿಕ ಉದಾಹರಣೆ: ನೀವು ವಿವಿಧ ಪ್ರದೇಶಗಳಿಂದ (ಉದಾಹರಣೆಗೆ, ಉತ್ತರ ಅಮೆರಿಕ, ಯುರೋಪ್, ಏಷ್ಯಾ) ಮಾರಾಟದ ಅಂಕಿಅಂಶಗಳ ಅರೇಯನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಒಟ್ಟು ಜಾಗತಿಕ ಮಾರಾಟವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನೀವು reduce() ಅನ್ನು ಬಳಸಬಹುದು.

5. ಅರೇಗಳನ್ನು ಹುಡುಕುವುದು: find(), findIndex(), includes(), indexOf(), lastIndexOf()

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳನ್ನು ಹುಡುಕಲು ಹಲವಾರು ಮೆಥಡ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

• find(): ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಫಂಕ್ಷನ್ ಅನ್ನು ಪೂರೈಸುವ ಅರೇಯಲ್ಲಿನ ಮೊದಲ ಎಲಿಮೆಂಟ್‌ನ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಯಾವುದೇ ಎಲಿಮೆಂಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಪೂರೈಸದಿದ್ದರೆ undefined ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• findIndex(): ಒದಗಿಸಿದ ಪರೀಕ್ಷಾ ಫಂಕ್ಷನ್ ಅನ್ನು ಪೂರೈಸುವ ಅರೇಯಲ್ಲಿನ ಮೊದಲ ಎಲಿಮೆಂಟ್‌ನ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಯಾವುದೇ ಎಲಿಮೆಂಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಪೂರೈಸದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• includes(): ಒಂದು ಅರೇಯು ಅದರ ಎಂಟ್ರಿಗಳ ನಡುವೆ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ, true ಅಥವಾ false ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• indexOf(): ನೀಡಿರುವ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಅರೇಯಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬಹುದಾದ ಮೊದಲ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಅದು ಇಲ್ಲದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• lastIndexOf(): ನೀಡಿರುವ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಅರೇಯಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬಹುದಾದ ಕೊನೆಯ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಅದು ಇಲ್ಲದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು:

const numbers = [1, 2, 3, 4, 5];

const foundNumber = numbers.find(number => number > 3);
console.log(foundNumber); // ಔಟ್‌ಪುಟ್: 4

const foundIndex = numbers.findIndex(number => number > 3);
console.log(foundIndex); // ಔಟ್‌ಪುಟ್: 3

const includesThree = numbers.includes(3);
console.log(includesThree); // ಔಟ್‌ಪುಟ್: true

const indexOfTwo = numbers.indexOf(2);
console.log(indexOfTwo); // ಔಟ್‌ಪುಟ್: 1

const lastIndexOfFour = [1, 2, 3, 4, 4, 5].lastIndexOf(4);
console.log(lastIndexOfFour); // ಔಟ್‌ಪುಟ್: 4

ಬಳಕೆಯ ಪ್ರಕರಣಗಳು: ಪಟ್ಟಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕುವುದು, ಶಾಪಿಂಗ್ ಕಾರ್ಟ್‌ನಲ್ಲಿ ಐಟಂ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು, ಅರೇಯಲ್ಲಿ ಎಲಿಮೆಂಟ್‌ನ ಸ್ಥಾನವನ್ನು ಪತ್ತೆ ಮಾಡುವುದು.

6. ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ತೆಗೆದುಹಾಕುವುದು: push(), pop(), shift(), unshift(), splice()

ಈ ಮೆಥಡ್‌ಗಳು ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸುವ ಅಥವಾ ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ಮೂಲ ಅರೇಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತವೆ:

• push(): ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಅರೇಯ ಕೊನೆಗೆ ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅರೇಯ ಹೊಸ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• pop(): ಅರೇಯಿಂದ ಕೊನೆಯ ಎಲಿಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಆ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• shift(): ಅರೇಯಿಂದ ಮೊದಲ ಎಲಿಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಆ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• unshift(): ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಅರೇಯ ಆರಂಭಕ್ಕೆ ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅರೇಯ ಹೊಸ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• splice(): ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಅಥವಾ ಬದಲಾಯಿಸುವ ಮತ್ತು/ಅಥವಾ ಹೊಸ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸ್ಥಳದಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ ಅರೇಯ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು:

const numbers = [1, 2, 3];

numbers.push(4, 5); // ಕೊನೆಗೆ 4 ಮತ್ತು 5 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ
console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5]

const lastElement = numbers.pop(); // ಕೊನೆಯ ಎಲಿಮೆಂಟ್ (5) ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ
console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4]
console.log(lastElement); // ಔಟ್‌ಪುಟ್: 5

const firstElement = numbers.shift(); // ಮೊದಲ ಎಲಿಮೆಂಟ್ (1) ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ
console.log(numbers); // ಔಟ್‌ಪುಟ್: [2, 3, 4]
console.log(firstElement); // ಔಟ್‌ಪುಟ್: 1

numbers.unshift(0); // ಆರಂಭಕ್ಕೆ 0 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ
console.log(numbers); // ಔಟ್‌ಪುಟ್: [0, 2, 3, 4]

numbers.splice(1, 2, 10, 20); // ಇಂಡೆಕ್ಸ್ 1 ರಿಂದ 2 ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಮತ್ತು 10 ಮತ್ತು 20 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ
console.log(numbers); // ಔಟ್‌ಪುಟ್: [0, 10, 20, 4]

ಬಳಕೆಯ ಪ್ರಕರಣಗಳು: ಕ್ಯೂ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು, ಶಾಪಿಂಗ್ ಕಾರ್ಟ್‌ಗೆ ಐಟಂಗಳನ್ನು ಸೇರಿಸುವುದು, ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡುವುದು.

7. ಸಬ್-ಅರೇಗಳನ್ನು ರಚಿಸುವುದು: slice()

slice() ಮೆಥಡ್, start ಮತ್ತು end ಅರೇಯ ಐಟಂಗಳ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ, start ನಿಂದ end (end ಒಳಗೊಂಡಿಲ್ಲ) ವರೆಗೆ ಆಯ್ಕೆಮಾಡಿದ ಅರೇಯ ಒಂದು ಭಾಗದ ಆಳವಿಲ್ಲದ ಪ್ರತಿಯನ್ನು ಹೊಸ ಅರೇ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮೂಲ ಅರೇಯನ್ನು ಮಾರ್ಪಡಿಸಲಾಗುವುದಿಲ್ಲ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

const newArray = array.slice(start, end);

ಉದಾಹರಣೆ:

const numbers = [1, 2, 3, 4, 5];
const subarray = numbers.slice(1, 4);
console.log(subarray); // ಔಟ್‌ಪುಟ್: [2, 3, 4]
console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5] (ಮೂಲ ಅರೇ ಬದಲಾಗುವುದಿಲ್ಲ)

ಬಳಕೆಯ ಪ್ರಕರಣ: ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ ಅರೇಯ ಒಂದು ಭಾಗವನ್ನು ಹೊರತೆಗೆಯುವುದು, ಅರೇಯ ಪ್ರತಿಯನ್ನು ರಚಿಸುವುದು.

8. ಅರೇಗಳನ್ನು ಸಾರ್ಟ್ ಮಾಡುವುದು: sort()

sort() ಮೆಥಡ್ ಅರೇಯ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸ್ಥಳದಲ್ಲಿಯೇ ಸಾರ್ಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಾರ್ಟ್ ಮಾಡಿದ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಸಾರ್ಟ್ ಕ್ರಮವು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿದೆ, ಇದು ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಿ, ನಂತರ ಅವುಗಳ UTF-16 ಕೋಡ್ ಯೂನಿಟ್ ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮಗಳನ್ನು ಹೋಲಿಸುವ ಮೂಲಕ ನಿರ್ಮಿಸಲಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

array.sort(compareFunction);

compareFunction ಐಚ್ಛಿಕವಾಗಿದೆ. ಇದನ್ನು ಬಿಟ್ಟರೆ, ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು UTF-16 ಕೋಡ್ ಯೂನಿಟ್ ಮೌಲ್ಯಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಸಾರ್ಟ್ ಮಾಡಲಾಗುತ್ತದೆ. ನೀವು ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಸಾರ್ಟ್ ಮಾಡಲು ಬಯಸಿದರೆ, ನೀವು ಹೋಲಿಕೆ ಫಂಕ್ಷನ್ ಅನ್ನು ಒದಗಿಸಬೇಕಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು:

const numbers = [3, 1, 4, 1, 5, 9, 2, 6];
numbers.sort(); // ಅಕ್ಷರಾನುಕ್ರಮವಾಗಿ ಸಾರ್ಟ್ ಮಾಡುತ್ತದೆ (ಸಂಖ್ಯೆಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಪರಿಗಣಿಸುತ್ತದೆ)
console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort((a, b) => a - b); // ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಸಾರ್ಟ್ ಮಾಡುತ್ತದೆ (ಆರೋಹಣ)
console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort((a, b) => b - a); // ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಸಾರ್ಟ್ ಮಾಡುತ್ತದೆ (ಅವರೋಹಣ)
console.log(numbers); // ಔಟ್‌ಪುಟ್: [9, 6, 5, 4, 3, 2, 1, 1]

ಬಳಕೆಯ ಪ್ರಕರಣ: ಉತ್ಪನ್ನಗಳ ಪಟ್ಟಿಯನ್ನು ಬೆಲೆಯ ಮೂಲಕ ಸಾರ್ಟ್ ಮಾಡುವುದು, ಬಳಕೆದಾರರನ್ನು ಹೆಸರಿನ ಮೂಲಕ ಸಾರ್ಟ್ ಮಾಡುವುದು, ಕಾರ್ಯಗಳನ್ನು ಆದ್ಯತೆಯ ಮೂಲಕ ಕ್ರಮಗೊಳಿಸುವುದು.

9. ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು: every(), some()

ಈ ಮೆಥಡ್‌ಗಳು ಅರೇಯಲ್ಲಿನ ಎಲ್ಲಾ ಅಥವಾ ಕೆಲವು ಎಲಿಮೆಂಟ್‌ಗಳು ಒಂದು ಷರತ್ತನ್ನು ಪೂರೈಸುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತವೆ:

• every(): ಅರೇಯಲ್ಲಿನ ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳು ಒದಗಿಸಿದ ಫಂಕ್ಷನ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾಗುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಇದು ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• some(): ಅರೇಯಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ಎಲಿಮೆಂಟ್ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾಗುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಅರೇಯಲ್ಲಿ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್‌ಗೆ true ಹಿಂತಿರುಗಿಸುವ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಕಂಡುಕೊಂಡರೆ ಅದು true ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ ಅದು false ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಅರೇಯನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ.

ಉದಾಹರಣೆಗಳು:

const numbers = [2, 4, 6, 8, 10];

const allEven = numbers.every(number => number % 2 === 0);
console.log(allEven); // ಔಟ್‌ಪುಟ್: true

const someOdd = numbers.some(number => number % 2 !== 0);
console.log(someOdd); // ಔಟ್‌ಪುಟ್: false

ಬಳಕೆಯ ಪ್ರಕರಣ: ಫಾರ್ಮ್ ಡೇಟಾವನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು, ಎಲ್ಲಾ ಬಳಕೆದಾರರು ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಒಪ್ಪಿಕೊಂಡಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು, ಶಾಪಿಂಗ್ ಕಾರ್ಟ್‌ನಲ್ಲಿರುವ ಯಾವುದೇ ಐಟಂಗಳು ಸ್ಟಾಕ್‌ನಿಂದ ಹೊರಗಿವೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವುದು.

10. ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು: join()

join() ಮೆಥಡ್ ಅರೇಯಲ್ಲಿನ (ಅಥವಾ ಅರೇ-ರೀತಿಯ ಆಬ್ಜೆಕ್ಟ್) ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಕಾಮಾಗಳಿಂದ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ವಿಭಜಕ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಬೇರ್ಪಡಿಸಿ, ಜೋಡಿಸುವ ಮೂಲಕ ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅರೇಯಲ್ಲಿ ಒಂದೇ ಐಟಂ ಇದ್ದರೆ, ಆ ಐಟಂ ಅನ್ನು ವಿಭಜಕವನ್ನು ಬಳಸದೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

const newString = array.join(separator);

ಉದಾಹರಣೆ:

const words = ["Hello", "World", "!"];
const sentence = words.join(" ");
console.log(sentence); // ಔಟ್‌ಪುಟ್: Hello World !

ಬಳಕೆಯ ಪ್ರಕರಣ: ಕಾಮಾದಿಂದ ಬೇರ್ಪಡಿಸಿದ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು, ಸೆಗ್ಮೆಂಟ್‌ಗಳ ಅರೇಯಿಂದ URL ಪಥವನ್ನು ರಚಿಸುವುದು.

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಪ್ರತಿ ಮೆಥಡ್ ಏನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ (ಹೊಸ ಅರೇ, ಒಂದೇ ಮೌಲ್ಯ, ಬೂಲಿಯನ್, ಇತ್ಯಾದಿ).
• ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ: map(), filter(), ಮತ್ತು slice() ನಂತಹ ಮೆಥಡ್‌ಗಳು ಹೊಸ ಅರೇಗಳನ್ನು ರಚಿಸುತ್ತವೆ, ಮೂಲ ಡೇಟಾವನ್ನು ಸಂರಕ್ಷಿಸುತ್ತವೆ. ಅನಿರೀಕ್ಷಿತ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಾಧ್ಯವಾದಾಗ ಮೂಲ ಅರೇಯನ್ನು ಮಾರ್ಪಡಿಸುವ ಮೆಥಡ್‌ಗಳ (push(), pop(), shift(), unshift(), splice(), sort()) ಬದಲಿಗೆ ಇವುಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ.
• ಚೈನಿಂಗ್: ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಓದಬಲ್ಲ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಬಹು ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಿ. ಉದಾಹರಣೆಗೆ:

  const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  const result = numbers
    .filter(number => number % 2 === 0) // ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ
    .map(number => number * 2); // 2 ರಿಂದ ಗುಣಿಸಿ
  console.log(result); // ಔಟ್‌ಪುಟ್: [4, 8, 12, 16, 20]

• ಕಾರ್ಯಕ್ಷಮತೆ: ಅರೇ ಮೆಥಡ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸಮರ್ಥವಾಗಿದ್ದರೂ, ಬಹಳ ದೊಡ್ಡ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಿ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಾಂಪ್ರದಾಯಿಕ for ಲೂಪ್ ವೇಗವಾಗಿರಬಹುದು.
• ಓದುವಿಕೆ: ನಿಮ್ಮ ಉದ್ದೇಶವನ್ನು ಉತ್ತಮವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುವ ಮೆಥಡ್ ಅನ್ನು ಆರಿಸಿ. ಉದಾಹರಣೆಗೆ, ಸರಳ ಇಟರೇಷನ್‌ಗಾಗಿ forEach(), ರೂಪಾಂತರಕ್ಕಾಗಿ map(), ಮತ್ತು ಆಯ್ಕೆಗಾಗಿ filter() ಬಳಸಿ.

ತೀರ್ಮಾನ

ಯಾವುದೇ ವೆಬ್ ಡೆವಲಪರ್‌ಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಅವು ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ರೂಪಾಂತರಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಸಮರ್ಥ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ಮೆಥಡ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೌಶಲ್ಯಗಳನ್ನು ನೀವು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು.

ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಗಟ್ಟಿಗೊಳಿಸಲು ಮತ್ತು ಅವುಗಳ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು ಈ ಮೆಥಡ್‌ಗಳನ್ನು ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಬಳಸುವುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಿ. ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!