ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳೊಂದಿಗೆ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಪರಿಣತಿ

ವೆಬ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ನಿರಂತರವಾಗಿ ವಿಕಸಿಸುತ್ತಿರುವ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಮೂಲಾಧಾರವಾಗಿ ಮುಂದುವರೆದಿದೆ. ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಮತ್ತು ಇಂಪರೇಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ಯಾರಾಡಿಗ್ಮ್‌ಗಳು ದೀರ್ಘಕಾಲದಿಂದ ಪ್ರಬಲವಾಗಿದ್ದರೂ, ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (FP) ಹೆಚ್ಚು ಗಮನ ಸೆಳೆಯುತ್ತಿದೆ. FP ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ, ಪ್ಯೂರ್ ಫಂಕ್ಷನ್‌ಗಳು, ಮತ್ತು ಡಿಕ್ಲರೇಟಿವ್ ಕೋಡ್‌ಗೆ ಒತ್ತು ನೀಡುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ದೃಢವಾದ, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ನಿರೀಕ್ಷಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಮಾರ್ಗವೆಂದರೆ ಅದರ ನೇಟಿವ್ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದು.

ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತತ್ವಗಳ ಶಕ್ತಿಯನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳಬಹುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ನಾವು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ಮತ್ತು map, filter, ಮತ್ತು reduce ನಂತಹ ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸಿ ಅವುಗಳನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸಬೇಕು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ, ಇದರಿಂದ ನೀವು ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಅನ್ನು ನಿಭಾಯಿಸುವ ವಿಧಾನವನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ.

ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂದರೇನು?

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳುವ ಮೊದಲು, ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸೋಣ. ಅದರ ಮೂಲದಲ್ಲಿ, FP ಎನ್ನುವುದು ಗಣಿತದ ಫಂಕ್ಷನ್‌ಗಳ ಮೌಲ್ಯಮಾಪನವಾಗಿ ಗಣನೆಯನ್ನು ಪರಿಗಣಿಸುವ ಮತ್ತು ಸ್ಟೇಟ್ ಬದಲಾವಣೆ ಹಾಗೂ ಮ್ಯೂಟಬಲ್ ಡೇಟಾವನ್ನು ತಪ್ಪಿಸುವ ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ಯಾರಾಡಿಗ್ಮ್ ಆಗಿದೆ. ಪ್ರಮುಖ ತತ್ವಗಳು ಹೀಗಿವೆ:

• ಶುದ್ಧ ಫಂಕ್ಷನ್‌ಗಳು (Pure Functions): ಒಂದು ಶುದ್ಧ ಫಂಕ್ಷನ್ ಯಾವಾಗಲೂ ಒಂದೇ ಇನ್‌ಪುಟ್‌ಗೆ ಒಂದೇ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಸೈಡ್ ಎಫೆಕ್ಟ್ಸ್ (ಬಾಹ್ಯ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ) ಹೊಂದಿರುವುದಿಲ್ಲ.
• ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ (Immutability): ಡೇಟಾವನ್ನು ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸುವ ಬದಲು, ಅಪೇಕ್ಷಿತ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಹೊಸ ಡೇಟಾವನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
• ಫಸ್ಟ್-ಕ್ಲಾಸ್ ಫಂಕ್ಷನ್‌ಗಳು (First-Class Functions): ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಯಾವುದೇ ಇತರ ವೇರಿಯಬಲ್‌ನಂತೆ ಪರಿಗಣಿಸಬಹುದು – ಅವುಗಳನ್ನು ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸಬಹುದು, ಇತರ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸಬಹುದು ಮತ್ತು ಫಂಕ್ಷನ್‌ಗಳಿಂದ ಹಿಂತಿರುಗಿಸಬಹುದು.
• ಡಿಕ್ಲರೇಟಿವ್ vs. ಇಂಪರೇಟಿವ್ (Declarative vs. Imperative): ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಡಿಕ್ಲರೇಟಿವ್ ಶೈಲಿಯ ಕಡೆಗೆ ಒಲವು ತೋರುತ್ತದೆ, ಇದರಲ್ಲಿ ನೀವು *ಏನು* ಸಾಧಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತೀರಿ, ಆದರೆ ಇಂಪರೇಟಿವ್ ಶೈಲಿಯಲ್ಲಿ ಅದನ್ನು ಹಂತ-ಹಂತವಾಗಿ *ಹೇಗೆ* ಸಾಧಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸಲಾಗುತ್ತದೆ.

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಮೆಥಡ್‌ಗಳ ಶಕ್ತಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳು ಸಾಂಪ್ರದಾಯಿಕ ಲೂಪ್‌ಗಳನ್ನು (for ಅಥವಾ while ನಂತಹ) ಆಶ್ರಯಿಸದೆಯೇ ಅತ್ಯಾಧುನಿಕ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗೆ ಅವಕಾಶ ನೀಡುವ ಶ್ರೀಮಂತ ಅಂತರ್ನಿರ್ಮಿತ ಮೆಥಡ್‌ಗಳ ಸಮೂಹವನ್ನು ಹೊಂದಿವೆ. ಈ ಮೆಥಡ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೊಸ ಅರೇಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ, ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತವೆ, ಮತ್ತು ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ, ಇದು ಫಂಕ್ಷನಲ್ ವಿಧಾನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ಅತ್ಯಂತ ಮೂಲಭೂತವಾದ ಫಂಕ್ಷನಲ್ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

1. Array.prototype.map()

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

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

array.map(callback(currentValue[, index[, array]])[, thisArg])

• callback: ಪ್ರತಿ ಎಲಿಮೆಂಟ್‌ಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಫಂಕ್ಷನ್.
• currentValue: ಅರೇಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್.
• index (ಐಚ್ಛಿಕ): ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್‌ನ ಇಂಡೆಕ್ಸ್.
• array (ಐಚ್ಛಿಕ): map ಅನ್ನು ಕರೆಯಲಾದ ಅರೇ.
• thisArg (ಐಚ್ಛಿಕ): callback ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ this ಆಗಿ ಬಳಸಬೇಕಾದ ಮೌಲ್ಯ.

ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣಗಳು:

• ಹೊಸ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• ಮೂಲ ಅರೇ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ (ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ).
• ಹೊಸ ಅರೇಯು ಮೂಲ ಅರೇಯಷ್ಟೇ ಉದ್ದವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
• ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಪ್ರತಿ ಎಲಿಮೆಂಟ್‌ಗೆ ಪರಿವರ್ತಿತ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

ಉದಾಹರಣೆ: ಪ್ರತಿ ಸಂಖ್ಯೆಯನ್ನು ದ್ವಿಗುಣಗೊಳಿಸುವುದು

ನಿಮ್ಮ ಬಳಿ ಸಂಖ್ಯೆಗಳ ಅರೇ ಇದೆ ಮತ್ತು ಪ್ರತಿ ಸಂಖ್ಯೆಯನ್ನು ದ್ವಿಗುಣಗೊಳಿಸಿ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸುತ್ತೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

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

// ರೂಪಾಂತರಕ್ಕಾಗಿ ಮ್ಯಾಪ್ ಬಳಸುವುದು
const doubledNumbers = numbers.map(number => number * 2);

console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5] (ಮೂಲ ಅರೇ ಬದಲಾಗಿಲ್ಲ)
console.log(doubledNumbers); // ಔಟ್‌ಪುಟ್: [2, 4, 6, 8, 10]

ಉದಾಹರಣೆ: ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಂದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು

ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇಯಿಂದ ನಿರ್ದಿಷ್ಟ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯಾಗಿದೆ. ನಮ್ಮ ಬಳಿ ಬಳಕೆದಾರರ ಪಟ್ಟಿ ಇದೆ ಮತ್ತು ಅವರ ಹೆಸರುಗಳನ್ನು ಮಾತ್ರ ಪಡೆಯಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ.

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

const userNames = users.map(user => user.name);

console.log(userNames); // ಔಟ್‌ಪುಟ್: ['Alice', 'Bob', 'Charlie']

2. Array.prototype.filter()

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

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

array.filter(callback(element[, index[, array]])[, thisArg])

• callback: ಪ್ರತಿ ಎಲಿಮೆಂಟ್‌ಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಫಂಕ್ಷನ್. ಎಲಿಮೆಂಟ್ ಅನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು true ಅಥವಾ ತಿರಸ್ಕರಿಸಲು false ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.
• element: ಅರೇಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್.
• index (ಐಚ್ಛಿಕ): ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್‌ನ ಇಂಡೆಕ್ಸ್.
• array (ಐಚ್ಛಿಕ): filter ಅನ್ನು ಕರೆಯಲಾದ ಅರೇ.
• thisArg (ಐಚ್ಛಿಕ): callback ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ this ಆಗಿ ಬಳಸಬೇಕಾದ ಮೌಲ್ಯ.

ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣಗಳು:

• ಹೊಸ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• ಮೂಲ ಅರೇ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ (ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ).
• ಹೊಸ ಅರೇಯು ಮೂಲ ಅರೇಗಿಂತ ಕಡಿಮೆ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
• ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

ಉದಾಹರಣೆ: ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು

ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಇರಿಸಿಕೊಳ್ಳಲು ಸಂಖ್ಯೆಗಳ ಅರೇಯನ್ನು ಫಿಲ್ಟರ್ ಮಾಡೋಣ.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಫಿಲ್ಟರ್ ಬಳಸುವುದು
const evenNumbers = numbers.filter(number => number % 2 === 0);

console.log(numbers); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(evenNumbers); // ಔಟ್‌ಪುಟ್: [2, 4, 6, 8, 10]

ಉದಾಹರಣೆ: ಸಕ್ರಿಯ ಬಳಕೆದಾರರನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು

ನಮ್ಮ ಬಳಕೆದಾರರ ಅರೇಯಿಂದ, ಸಕ್ರಿಯ ಎಂದು ಗುರುತಿಸಲಾದ ಬಳಕೆದಾರರಿಗಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡೋಣ.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: false }
];

const activeUsers = users.filter(user => user.isActive);

console.log(activeUsers); 
/* ಔಟ್‌ಪುಟ್:
[
  { id: 1, name: 'Alice', isActive: true },
  { id: 3, name: 'Charlie', isActive: true }
]
*/

3. Array.prototype.reduce()

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

ಇದು ಬಹುಶಃ ಅರೇ ಮೆಥಡ್‌ಗಳಲ್ಲಿ ಅತ್ಯಂತ ಬಹುಮುಖವಾಗಿದೆ ಮತ್ತು ಅನೇಕ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಮೂಲಾಧಾರವಾಗಿದೆ, ಇದು ನಿಮಗೆ ಅರೇಯನ್ನು ಒಂದೇ ಮೌಲ್ಯಕ್ಕೆ (ಉದಾ., ಮೊತ್ತ, ಗುಣಲಬ್ಧ, ಎಣಿಕೆ, ಅಥವಾ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅಥವಾ ಅರೇ) “ಕಡಿಮೆ” ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

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

array.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

• callback: ಪ್ರತಿ ಎಲಿಮೆಂಟ್‌ಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಫಂಕ್ಷನ್.
• accumulator: ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್‌ನ ಹಿಂದಿನ ಕರೆಯಿಂದ ಉಂಟಾದ ಮೌಲ್ಯ. ಮೊದಲ ಕರೆಯಲ್ಲಿ, ಇದು ಒದಗಿಸಿದರೆ initialValue ಆಗಿರುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಅರೇಯ ಮೊದಲ ಎಲಿಮೆಂಟ್ ಆಗಿರುತ್ತದೆ.
• currentValue: ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್.
• index (ಐಚ್ಛಿಕ): ಪ್ರಸ್ತುತ ಎಲಿಮೆಂಟ್‌ನ ಇಂಡೆಕ್ಸ್.
• array (ಐಚ್ಛಿಕ): reduce ಅನ್ನು ಕರೆಯಲಾದ ಅರೇ.
• initialValue (ಐಚ್ಛಿಕ): callback ನ ಮೊದಲ ಕರೆಗೆ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಬಳಸಬೇಕಾದ ಮೌಲ್ಯ. ಯಾವುದೇ initialValue ಅನ್ನು ಒದಗಿಸದಿದ್ದರೆ, ಅರೇಯ ಮೊದಲ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಆರಂಭಿಕ accumulator ಮೌಲ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಇಟರೇಷನ್ ಎರಡನೇ ಎಲಿಮೆಂಟ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣಗಳು:

• ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ (ಇದು ಅರೇ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಕೂಡ ಆಗಿರಬಹುದು).
• ಮೂಲ ಅರೇ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ (ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ).
• initialValue ಸ್ಪಷ್ಟತೆಗಾಗಿ ಮತ್ತು ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಖಾಲಿ ಅರೇಗಳೊಂದಿಗೆ ಅಥವಾ ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ಪ್ರಕಾರವು ಅರೇ ಎಲಿಮೆಂಟ್ ಪ್ರಕಾರಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿದ್ದಾಗ.

ಉದಾಹರಣೆ: ಸಂಖ್ಯೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುವುದು

ನಮ್ಮ ಅರೇಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸೋಣ.

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

// ಸಂಖ್ಯೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ರಿಡ್ಯೂಸ್ ಬಳಸುವುದು
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0); // 0 ಎಂಬುದು initialValue

console.log(sum); // ಔಟ್‌ಪುಟ್: 15

ವಿವರಣೆ:

• ಕರೆ 1: accumulator 0, currentValue 1. ಹಿಂತಿರುಗಿಸುತ್ತದೆ 0 + 1 = 1.
• ಕರೆ 2: accumulator 1, currentValue 2. ಹಿಂತಿರುಗಿಸುತ್ತದೆ 1 + 2 = 3.
• ಕರೆ 3: accumulator 3, currentValue 3. ಹಿಂತಿರುಗಿಸುತ್ತದೆ 3 + 3 = 6.
• ಮತ್ತು ಹೀಗೆ, ಅಂತಿಮ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವವರೆಗೆ.

ಉದಾಹರಣೆ: ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಒಂದು ಪ್ರಾಪರ್ಟಿ ಮೂಲಕ ಗುಂಪು ಮಾಡುವುದು

ನಾವು reduce ಅನ್ನು ಬಳಸಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇಯನ್ನು ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಪರ್ಟಿ ಮೂಲಕ ಗುಂಪು ಮಾಡಲಾದ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ನಮ್ಮ ಬಳಕೆದಾರರನ್ನು ಅವರ `isActive` ಸ್ಥಿತಿಯ ಮೂಲಕ ಗುಂಪು ಮಾಡೋಣ.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: false }
];

const groupedUsers = users.reduce((acc, user) => {
  const status = user.isActive ? 'active' : 'inactive';
  if (!acc[status]) {
    acc[status] = [];
  }
  acc[status].push(user);
  return acc;
}, {}); // ಖಾಲಿ ಆಬ್ಜೆಕ್ಟ್ {} ಎಂಬುದು initialValue

console.log(groupedUsers);
/* ಔಟ್‌ಪುಟ್:
{
  active: [
    { id: 1, name: 'Alice', isActive: true },
    { id: 3, name: 'Charlie', isActive: true }
  ],
  inactive: [
    { id: 2, name: 'Bob', isActive: false },
    { id: 4, name: 'David', isActive: false }
  ]
}
*/

ಉದಾಹರಣೆ: ಸಂಭವಿಸುವಿಕೆಗಳನ್ನು ಎಣಿಸುವುದು

ಒಂದು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಹಣ್ಣಿನ ಆವರ್ತನವನ್ನು ಎಣಿಸೋಣ.

const fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple'];

const fruitCounts = fruits.reduce((acc, fruit) => {
  acc[fruit] = (acc[fruit] || 0) + 1;
  return acc;
}, {});

console.log(fruitCounts); // ಔಟ್‌ಪುಟ್: { apple: 3, banana: 2, orange: 1 }

4. Array.prototype.forEach()

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

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

array.forEach(callback(element[, index[, array]])[, thisArg])

ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣಗಳು:

• undefined ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• ಪ್ರತಿ ಅರೇ ಎಲಿಮೆಂಟ್‌ಗೆ ಒಮ್ಮೆ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
• ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗಿಂಗ್ ಮಾಡುವುದು ಅಥವಾ DOM ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ನವೀಕರಿಸುವಂತಹ ಸೈಡ್ ಎಫೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಪ್ರತಿ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಲಾಗ್ ಮಾಡುವುದು

const messages = ['Hello', 'Functional', 'World'];

messages.forEach(message => console.log(message));
// ಔಟ್‌ಪುಟ್:
// Hello
// Functional
// World

ಗಮನಿಸಿ: ರೂಪಾಂತರಗಳು ಮತ್ತು ಫಿಲ್ಟರಿಂಗ್‌ಗಾಗಿ, map ಮತ್ತು filter ಅವುಗಳ ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ ಮತ್ತು ಡಿಕ್ಲರೇಟಿವ್ ಸ್ವರೂಪದಿಂದಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ. ನೀವು ನಿರ್ದಿಷ್ಟವಾಗಿ ಪ್ರತಿ ಐಟಂಗೆ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಸ ರಚನೆಗೆ ಸಂಗ್ರಹಿಸದೆ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ forEach ಬಳಸಿ.

5. Array.prototype.find() ಮತ್ತು Array.prototype.findIndex()

ಈ ಮೆಥಡ್‌ಗಳು ಅರೇಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಉಪಯುಕ್ತವಾಗಿವೆ.

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

ಉದಾಹರಣೆ: ಬಳಕೆದಾರರನ್ನು ಹುಡುಕುವುದು

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

const bob = users.find(user => user.name === 'Bob');
const bobIndex = users.findIndex(user => user.name === 'Bob');
const nonExistentUser = users.find(user => user.name === 'David');
const nonExistentIndex = users.findIndex(user => user.name === 'David');

console.log(bob); // ಔಟ್‌ಪುಟ್: { id: 2, name: 'Bob' }
console.log(bobIndex); // ಔಟ್‌ಪುಟ್: 1
console.log(nonExistentUser); // ಔಟ್‌ಪುಟ್: undefined
console.log(nonExistentIndex); // ಔಟ್‌ಪುಟ್: -1

6. Array.prototype.some() ಮತ್ತು Array.prototype.every()

ಈ ಮೆಥಡ್‌ಗಳು ಅರೇಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳು ಒದಗಿಸಿದ ಫಂಕ್ಷನ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾಗುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತವೆ.

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

ಉದಾಹರಣೆ: ಬಳಕೆದಾರರ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುವುದು

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true }
];

const hasInactiveUser = users.some(user => !user.isActive);
const allAreActive = users.every(user => user.isActive);

console.log(hasInactiveUser); // ಔಟ್‌ಪುಟ್: true (ಏಕೆಂದರೆ ಬಾಬ್ ನಿಷ್ಕ್ರಿಯ)
console.log(allAreActive); // ಔಟ್‌ಪುಟ್: false (ಏಕೆಂದರೆ ಬಾಬ್ ನಿಷ್ಕ್ರಿಯ)

const allUsersActive = users.filter(user => user.isActive).length === users.length;
console.log(allUsersActive); // ಔಟ್‌ಪುಟ್: false

// ನೇರವಾಗಿ every ಬಳಸಿ ಪರ್ಯಾಯ
const allUsersActiveDirect = users.every(user => user.isActive);
console.log(allUsersActiveDirect); // ಔಟ್‌ಪುಟ್: false

ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಅರೇ ಮೆಥಡ್‌ಗಳನ್ನು ಚೈನ್ ಮಾಡುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳೊಂದಿಗೆ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ನಿಜವಾದ ಶಕ್ತಿಯು ನೀವು ಈ ಮೆಥಡ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಚೈನ್ ಮಾಡಿದಾಗ ಹೊಳೆಯುತ್ತದೆ. ಈ ಮೆಥಡ್‌ಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಹೊಸ ಅರೇಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವುದರಿಂದ (forEach ಹೊರತುಪಡಿಸಿ), ನೀವು ಒಂದು ಮೆಥಡ್‌ನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಇನ್ನೊಂದರ ಇನ್‌ಪುಟ್‌ಗೆ ಮನಬಂದಂತೆ ಪೈಪ್ ಮಾಡಬಹುದು, ಇದು ಸೊಗಸಾದ ಮತ್ತು ಓದಬಲ್ಲ ಡೇಟಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಸಕ್ರಿಯ ಬಳಕೆದಾರರ ಹೆಸರುಗಳನ್ನು ಹುಡುಕುವುದು ಮತ್ತು ಅವರ IDಗಳನ್ನು ದ್ವಿಗುಣಗೊಳಿಸುವುದು

ಎಲ್ಲಾ ಸಕ್ರಿಯ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕೋಣ, ಅವರ ಹೆಸರುಗಳನ್ನು ಹೊರತೆಗೆಯೋಣ, ಮತ್ತು ನಂತರ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸೋಣ, ಅಲ್ಲಿ ಪ್ರತಿ ಹೆಸರಿಗೆ *ಫಿಲ್ಟರ್ ಮಾಡಿದ* ಪಟ್ಟಿಯಲ್ಲಿ ಅದರ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಅವರ IDಗಳನ್ನು ದ್ವಿಗುಣಗೊಳಿಸಲಾಗುತ್ತದೆ.

const users = [
  { id: 1, name: 'Alice', isActive: true },
  { id: 2, name: 'Bob', isActive: false },
  { id: 3, name: 'Charlie', isActive: true },
  { id: 4, name: 'David', isActive: true },
  { id: 5, name: 'Eve', isActive: false }
];

const processedActiveUsers = users
  .filter(user => user.isActive) // ಕೇವಲ ಸಕ್ರಿಯ ಬಳಕೆದಾರರನ್ನು ಪಡೆಯಿರಿ
  .map((user, index) => ({      // ಪ್ರತಿ ಸಕ್ರಿಯ ಬಳಕೆದಾರರನ್ನು ಪರಿವರ್ತಿಸಿ
    name: `${index + 1}. ${user.name}`,
    doubledId: user.id * 2
  }));

console.log(processedActiveUsers);
/* ಔಟ್‌ಪುಟ್:
[
  { name: '1. Alice', doubledId: 2 },
  { name: '2. Charlie', doubledId: 6 },
  { name: '3. David', doubledId: 8 }
]
*/

ಈ ಚೈನ್ ಮಾಡಿದ ವಿಧಾನವು ಡಿಕ್ಲರೇಟಿವ್ ಆಗಿದೆ: ನಾವು ಸ್ಪಷ್ಟವಾದ ಲೂಪ್ ನಿರ್ವಹಣೆಯಿಲ್ಲದೆ ಹಂತಗಳನ್ನು (ಫಿಲ್ಟರ್, ನಂತರ ಮ್ಯಾಪ್) ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ. ಇದು ಇಮ್ಮ್ಯೂಟಬಲ್ ಕೂಡ ಆಗಿದೆ, ಏಕೆಂದರೆ ಪ್ರತಿ ಹಂತವು ಹೊಸ ಅರೇ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಮೂಲ users ಅರೇಯನ್ನು ಹಾಗೆಯೇ ಬಿಡುತ್ತದೆ.

ಆಚರಣೆಯಲ್ಲಿ ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ

ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿಯ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ. ಇದರರ್ಥ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಮಾರ್ಪಡಿಸುವ ಬದಲು, ನೀವು ಅಪೇಕ್ಷಿತ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಹೊಸದನ್ನು ರಚಿಸುತ್ತೀರಿ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ map, filter, ಮತ್ತು slice ನಂತಹ ಅರೇ ಮೆಥಡ್‌ಗಳು ಹೊಸ ಅರೇಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೂಲಕ ಇದನ್ನು ಅಂತರ್ಗತವಾಗಿ ಬೆಂಬಲಿಸುತ್ತವೆ.

ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ ಏಕೆ ಮುಖ್ಯ?

• ನಿರೀಕ್ಷೆ (Predictability): ಹಂಚಿಕೆಯಾದ ಮ್ಯೂಟಬಲ್ ಸ್ಥಿತಿಯ ಬದಲಾವಣೆಗಳನ್ನು ನೀವು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾಗಿಲ್ಲದ ಕಾರಣ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
• ಡೀಬಗ್ ಮಾಡುವುದು (Debugging): ಬಗ್‌ಗಳು ಸಂಭವಿಸಿದಾಗ, ಡೇಟಾ ಅನಿರೀಕ್ಷಿತವಾಗಿ ಮಾರ್ಪಡಿಸದಿದ್ದಾಗ ಸಮಸ್ಯೆಯ ಮೂಲವನ್ನು ಗುರುತಿಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
• ಕಾರ್ಯಕ್ಷಮತೆ (Performance): ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ (ರೆಡಕ್ಸ್ ಅಥವಾ ರಿಯಾಕ್ಟ್‌ನಂತಹ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ), ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ ಸಮರ್ಥ ಬದಲಾವಣೆ ಪತ್ತೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ಏಕಕಾಲಿಕತೆ (Concurrency): ಇಮ್ಮ್ಯೂಟಬಲ್ ಡೇಟಾ ರಚನೆಗಳು ಅಂತರ್ಗತವಾಗಿ ಥ್ರೆಡ್-ಸುರಕ್ಷಿತವಾಗಿವೆ, ಇದು ಏಕಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

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

ಉದಾಹರಣೆ: ಎಲಿಮೆಂಟ್ ಅನ್ನು ಇಮ್ಮ್ಯೂಟಬಲ್ ಆಗಿ ಸೇರಿಸುವುದು

const originalArray = [1, 2, 3];

// ಇಂಪರೇಟಿವ್ ವಿಧಾನ (originalArray ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ)
// originalArray.push(4);

// ಸ್ಪ್ರೆಡ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ಫಂಕ್ಷನಲ್ ವಿಧಾನ
const newArrayWithPush = [...originalArray, 4];
console.log(originalArray); // ಔಟ್‌ಪುಟ್: [1, 2, 3]
console.log(newArrayWithPush); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4]

// slice ಮತ್ತು concatenation ಬಳಸಿ ಫಂಕ್ಷನಲ್ ವಿಧಾನ (ಈಗ ಕಡಿಮೆ ಸಾಮಾನ್ಯ)
const newArrayWithSlice = originalArray.slice(0, originalArray.length).concat(4);
console.log(newArrayWithSlice); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4]

ಉದಾಹರಣೆ: ಎಲಿಮೆಂಟ್ ಅನ್ನು ಇಮ್ಮ್ಯೂಟಬಲ್ ಆಗಿ ತೆಗೆದುಹಾಕುವುದು

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

// ಇಂಡೆಕ್ಸ್ 2 ರಲ್ಲಿರುವ ಎಲಿಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿ (ಮೌಲ್ಯ 3)

// slice ಮತ್ತು ಸ್ಪ್ರೆಡ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ಫಂಕ್ಷನಲ್ ವಿಧಾನ
const newArrayAfterSplice = [
  ...originalArray.slice(0, 2),
  ...originalArray.slice(3)
];
console.log(originalArray); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5]
console.log(newArrayAfterSplice); // ಔಟ್‌ಪುಟ್: [1, 2, 4, 5]

// ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಹಾಕಲು ಫಿಲ್ಟರ್ ಬಳಸುವುದು
const newValueToRemove = 3;
const arrayWithoutValue = originalArray.filter(item => item !== newValueToRemove);
console.log(arrayWithoutValue); // ಔಟ್‌ಪುಟ್: [1, 2, 4, 5]

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಸುಧಾರಿತ ತಂತ್ರಗಳು

ನೀವು ಫಂಕ್ಷನಲ್ ಅರೇ ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಆರಾಮದಾಯಕವಾದಂತೆ, ಈ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಓದುವಿಕೆಗೆ ಮೊದಲ ಆದ್ಯತೆ: ಚೈನಿಂಗ್ ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಅತಿ ಉದ್ದದ ಚೈನ್‌ಗಳು ಓದಲು ಕಷ್ಟವಾಗಬಹುದು. ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಣ್ಣ, ಹೆಸರಿಸಲಾದ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವುದನ್ನು ಅಥವಾ ಮಧ್ಯಂತರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• reduce ನ ನಮ್ಯತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: reduce ಕೇವಲ ಒಂದೇ ಮೌಲ್ಯಗಳಲ್ಲದೆ, ಅರೇಗಳು ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ. ಇದು ಸಂಕೀರ್ಣ ರೂಪಾಂತರಗಳಿಗೆ ಇದನ್ನು ನಂಬಲಾಗದಷ್ಟು ಬಹುಮುಖವಾಗಿಸುತ್ತದೆ.
• ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳಲ್ಲಿ ಸೈಡ್ ಎಫೆಕ್ಟ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ: ನಿಮ್ಮ map, filter, ಮತ್ತು reduce ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳನ್ನು ಶುದ್ಧವಾಗಿಡಲು ಶ್ರಮಿಸಿ. ನೀವು ಸೈಡ್ ಎಫೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದರೆ, forEach ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ.
• ಆರೋ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿ: ಆರೋ ಫಂಕ್ಷನ್‌ಗಳು (=>) ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಸಂಕ್ಷಿಪ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ ಮತ್ತು `this` ಬೈಂಡಿಂಗ್ ಅನ್ನು ವಿಭಿನ್ನವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಫಂಕ್ಷನಲ್ ಅರೇ ಮೆಥಡ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.
• ಲೈಬ್ರರಿಗಳನ್ನು ಪರಿಗಣಿಸಿ: ಹೆಚ್ಚು ಸುಧಾರಿತ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ಯಾಟರ್ನ್‌ಗಳಿಗಾಗಿ ಅಥವಾ ನೀವು ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿಯೊಂದಿಗೆ ವ್ಯಾಪಕವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, Lodash/fp, Ramda, ಅಥವಾ Immutable.js ನಂತಹ ಲೈಬ್ರರಿಗಳು ಪ್ರಯೋಜನಕಾರಿಯಾಗಬಹುದು, ಆದರೂ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಫಂಕ್ಷನಲ್ ಅರೇ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ.

ಉದಾಹರಣೆ: ಡೇಟಾ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗೆ ಫಂಕ್ಷನಲ್ ವಿಧಾನ

ನೀವು ವಿವಿಧ ಪ್ರದೇಶಗಳಿಂದ ಮಾರಾಟ ಡೇಟಾವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ಪ್ರತಿ ಪ್ರದೇಶಕ್ಕೆ ಒಟ್ಟು ಮಾರಾಟವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ನಂತರ ಅತಿ ಹೆಚ್ಚು ಮಾರಾಟವಿರುವ ಪ್ರದೇಶವನ್ನು ಹುಡುಕಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

const salesData = [
  { region: 'North', amount: 100 },
  { region: 'South', amount: 150 },
  { region: 'North', amount: 120 },
  { region: 'East', amount: 200 },
  { region: 'South', amount: 180 },
  { region: 'North', amount: 90 }
];

// 1. reduce ಬಳಸಿ ಪ್ರತಿ ಪ್ರದೇಶಕ್ಕೆ ಒಟ್ಟು ಮಾರಾಟವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ
const salesByRegion = salesData.reduce((acc, sale) => {
  acc[sale.region] = (acc[sale.region] || 0) + sale.amount;
  return acc;
}, {});

// salesByRegion ಹೀಗಿರುತ್ತದೆ: { North: 310, South: 330, East: 200 }

// 2. ಒಟ್ಟುಗೂಡಿಸಿದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೆಚ್ಚಿನ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇಗೆ ಪರಿವರ್ತಿಸಿ
const salesArray = Object.keys(salesByRegion).map(region => ({
  region: region,
  totalAmount: salesByRegion[region]
}));

// salesArray ಹೀಗಿರುತ್ತದೆ: [
//   { region: 'North', totalAmount: 310 },
//   { region: 'South', totalAmount: 330 },
//   { region: 'East', totalAmount: 200 }
// ]

// 3. reduce ಬಳಸಿ ಅತಿ ಹೆಚ್ಚು ಮಾರಾಟವಿರುವ ಪ್ರದೇಶವನ್ನು ಹುಡುಕಿ
const highestSalesRegion = salesArray.reduce((max, current) => {
  return current.totalAmount > max.totalAmount ? current : max;
}, { region: '', totalAmount: -Infinity }); // ಅತಿ ಚಿಕ್ಕ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ

console.log('ಪ್ರದೇಶವಾರು ಮಾರಾಟ:', salesByRegion);
console.log('ಮಾರಾಟದ ಅರೇ:', salesArray);
console.log('ಅತಿ ಹೆಚ್ಚು ಮಾರಾಟವಿರುವ ಪ್ರದೇಶ:', highestSalesRegion);

/*
ಔಟ್‌ಪುಟ್:
ಪ್ರದೇಶವಾರು ಮಾರಾಟ: { North: 310, South: 330, East: 200 }
ಮಾರಾಟದ ಅರೇ: [
  { region: 'North', totalAmount: 310 },
  { region: 'South', totalAmount: 330 },
  { region: 'East', totalAmount: 200 }
]
ಅತಿ ಹೆಚ್ಚು ಮಾರಾಟವಿರುವ ಪ್ರದೇಶ: { region: 'South', totalAmount: 330 }
*/

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳೊಂದಿಗೆ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕೇವಲ ಒಂದು ಶೈಲಿಯ ಆಯ್ಕೆಯಲ್ಲ; ಇದು ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ನಿರೀಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ದೃಢವಾದ ಕೋಡ್ ಬರೆಯಲು ಒಂದು ಶಕ್ತಿಶಾಲಿ ಮಾರ್ಗವಾಗಿದೆ. map, filter, ಮತ್ತು reduce ನಂತಹ ಮೆಥಡ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಮೂಲ ತತ್ವಗಳಿಗೆ, ವಿಶೇಷವಾಗಿ ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿ ಮತ್ತು ಶುದ್ಧ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಬದ್ಧರಾಗಿ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು, ಪ್ರಶ್ನಿಸಬಹುದು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸಬಹುದು.

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