ಕಾರ್ಯಕ್ಷಮತೆ ಹೋಲಿಕೆ: ಫಾರ್ ಲೂಪ್ ವರ್ಸಸ್ ಫೋರ್‌ಈಚ್ ವರ್ಸಸ್ ಮ್ಯಾಪ್ ಇನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಸಿಂಟ್ಯಾಕ್ಸ್, ಕಾರ್ಯಚಟುವಟಿಕೆ ಮತ್ತು ಮುಖ್ಯವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ. for ಲೂಪ್‌ಗಳು, forEach ಮತ್ತು map ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಮರ್ಥ ಮತ್ತು ಆಪ್ಟಿಮೈಸ್ಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಬರೆಯಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳು ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ. ಈ ಲೇಖನವು ಸಮಗ್ರ ಕಾರ್ಯಕ್ಷಮತೆ ಹೋಲಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪ್ರತಿ ವಿಧಾನದ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕೆಂದು ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ.

ಪರಿಚಯ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪುನರಾವರ್ತಿಸುವುದು

ಅರೇಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವುದು ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಕಾರ್ಯವಾಗಿದೆ. ಇದನ್ನು ಸಾಧಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ನಾವು ಮೂರು ಸಾಮಾನ್ಯ ವಿಧಾನಗಳ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ:

• for ಲೂಪ್: ಪುನರಾವರ್ತಿಸಲು ಸಾಂಪ್ರದಾಯಿಕ ಮತ್ತು ವಾದಯೋಗ್ಯವಾಗಿ ಅತ್ಯಂತ ಮೂಲಭೂತ ಮಾರ್ಗ.
• forEach: ಅರೇಯಲ್ಲಿನ ಅಂಶಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಮತ್ತು ಪ್ರತಿ ಅಂಶಕ್ಕಾಗಿ ಒದಗಿಸಿದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಒಂದು ಉನ್ನತ-ಕ್ರಮದ ಕಾರ್ಯ.
• map: ಕರೆ ಮಾಡುವ ಅರೇಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೇಲೆ ಒದಗಿಸಲಾದ ಕಾರ್ಯವನ್ನು ಕರೆ ಮಾಡುವುದರ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುವ ಮತ್ತೊಂದು ಉನ್ನತ-ಕ್ರಮದ ಕಾರ್ಯ.

ಸರಿಯಾದ ಪುನರಾವರ್ತನೆ ವಿಧಾನವನ್ನು ಆರಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಗಮನಾರ್ಹವಾಗಿ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಪ್ರತಿಯೊಂದು ವಿಧಾನವನ್ನು ಪರಿಶೀಲಿಸೋಣ ಮತ್ತು ಅವುಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ.

for ಲೂಪ್: ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನ

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

ಸಂಶ್ಲೇಷಣೆ ಮತ್ತು ಬಳಕೆ

for ಲೂಪ್‌ನ ಸಂಶ್ಲೇಷಣೆ ಸರಳವಾಗಿದೆ:

for (let i = 0; i < array.length; i++) {
  // ಪ್ರತಿ ಅಂಶಕ್ಕಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್
  console.log(array[i]);
}

ಘಟಕಗಳ ಸ್ಥಗಿತ ಇಲ್ಲಿದೆ:

• ಆರಂಭಿಕಗೊಳಿಸುವಿಕೆ (let i = 0): ಕೌಂಟರ್ ವೇರಿಯಬಲ್ (i) ಅನ್ನು 0 ಗೆ ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದನ್ನು ಲೂಪ್‌ನ ಆರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
• ಷರತ್ತು (i < array.length): ಲೂಪ್ ಮುಂದುವರಿಯಲು ನಿಜವಾಗಿರಬೇಕಾದ ಷರತ್ತುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. i ಅರೇಯ ಉದ್ದಕ್ಕಿಂತ ಕಡಿಮೆಯಿರುವವರೆಗೆ ಲೂಪ್ ಮುಂದುವರಿಯುತ್ತದೆ.
• ಹೆಚ್ಚಳ (i++): ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ನಂತರ ಕೌಂಟರ್ ವೇರಿಯಬಲ್ (i) ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳು

for ಲೂಪ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವೇಗವಾದ ಪುನರಾವರ್ತನೆ ವಿಧಾನವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಇದು ಕಡಿಮೆ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ನೀಡುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ನೇರವಾಗಿ ಕೌಂಟರ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಸೂಚ್ಯಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ಅರೇ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು:

• ವೇಗ: ಕಡಿಮೆ ಓವರ್‌ಹೆಡ್‌ನಿಂದಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ವೇಗವಾಗಿರುತ್ತದೆ.
• ನಿಯಂತ್ರಣ: ಸ್ಕಿಪ್ ಎಲಿಮೆಂಟ್ ಅಥವಾ ಲೂಪ್‌ನಿಂದ ಹೊರಬರುವ ಸಾಮರ್ಥ್ಯ ಸೇರಿದಂತೆ, ಪುನರಾವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಸಂಪೂರ್ಣ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ: ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳು ಸೇರಿದಂತೆ ಎಲ್ಲಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಪ್ರಪಂಚದಾದ್ಯಂತದ ಆರ್ಡರ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು

ನೀವು ವಿವಿಧ ದೇಶಗಳಿಂದ ಆರ್ಡರ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ. ತೆರಿಗೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಕೆಲವು ದೇಶಗಳಿಂದ ಆರ್ಡರ್‌ಗಳನ್ನು ನೀವು ವಿಭಿನ್ನವಾಗಿ ನಿರ್ವಹಿಸಬೇಕಾಗಬಹುದು.

const orders = [
  { id: 1, country: 'USA', amount: 100 },
  { id: 2, country: 'Canada', amount: 50 },
  { id: 3, country: 'UK', amount: 75 },
  { id: 4, country: 'Germany', amount: 120 },
  { id: 5, country: 'USA', amount: 80 }
];

function processOrders(orders) {
  for (let i = 0; i < orders.length; i++) {
    const order = orders[i];
    if (order.country === 'USA') {
      console.log(`Processing USA order ${order.id} with amount ${order.amount}`);
      // USA-ನಿರ್ದಿಷ್ಟ ತೆರಿಗೆ ತರ್ಕವನ್ನು ಅನ್ವಯಿಸಿ
    } else {
      console.log(`Processing order ${order.id} with amount ${order.amount}`);
    }
  }
}

processOrders(orders);

forEach: ಪುನರಾವರ್ತನೆಗೆ ಕ್ರಿಯಾತ್ಮಕ ವಿಧಾನ

forEach ಎನ್ನುವುದು ಅರೇಗಳಲ್ಲಿ ಲಭ್ಯವಿರುವ ಒಂದು ಉನ್ನತ-ಕ್ರಮದ ಕಾರ್ಯವಾಗಿದ್ದು, ಪುನರಾವರ್ತಿಸಲು ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಒದಗಿಸಿದ ಕಾರ್ಯವನ್ನು ಪ್ರತಿ ಅರೇ ಅಂಶಕ್ಕಾಗಿ ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

ಸಂಶ್ಲೇಷಣೆ ಮತ್ತು ಬಳಕೆ

forEach ನ ಸಂಶ್ಲೇಷಣೆ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

array.forEach(function(element, index, array) {
  // ಪ್ರತಿ ಅಂಶಕ್ಕಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್
  console.log(element, index, array);
});

ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವು ಮೂರು ವಾದಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:

• element: ಅರೇನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಅಂಶ.
• index (ಐಚ್ಛಿಕ): ಅರೇನಲ್ಲಿನ ಪ್ರಸ್ತುತ ಅಂಶದ ಸೂಚ್ಯಂಕ.
• array (ಐಚ್ಛಿಕ): forEach ಅನ್ನು ಯಾವ ಮೇಲೆ ಕರೆಯಲಾಗಿದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳು

forEach ಸಾಮಾನ್ಯವಾಗಿ for ಲೂಪ್‌ಗಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಏಕೆಂದರೆ forEach ಪ್ರತಿ ಅಂಶಕ್ಕಾಗಿ ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯಕ್ಕೆ ಸೇರಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಸಣ್ಣ ಅರೇಗಳಿಗಾಗಿ ವ್ಯತ್ಯಾಸವು ಅತ್ಯಲ್ಪವಾಗಿರಬಹುದು.

ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು:

• ಓದಬಲ್ಲದು: for ಲೂಪ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಓದಬಲ್ಲ ಸಂಶ್ಲೇಷಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳಿಗೆ ಚೆನ್ನಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.

ಪ್ರಮುಖ ಅನಾನುಕೂಲಗಳು:

• ನಿಧಾನ ಕಾರ್ಯಕ್ಷಮತೆ: ಸಾಮಾನ್ಯವಾಗಿ for ಲೂಪ್‌ಗಳಿಗಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ.
• ಮುರಿಯಲು ಅಥವಾ ಮುಂದುವರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ: ಲೂಪ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ನೀವು break ಅಥವಾ continue ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಪುನರಾವರ್ತನೆಯನ್ನು ನಿಲ್ಲಿಸಲು, ನೀವು ಒಂದು ವಿನಾಯಿತಿ ಎಸೆಯಬೇಕು ಅಥವಾ ಕಾರ್ಯದಿಂದ ಹಿಂತಿರುಗಬೇಕು (ಇದು ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆಯನ್ನು ಮಾತ್ರ ಬಿಟ್ಟುಬಿಡುತ್ತದೆ).

ಉದಾಹರಣೆ: ವಿವಿಧ ಪ್ರದೇಶಗಳಿಂದ ದಿನಾಂಕಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು

ನೀವು ಪ್ರಮಾಣಿತ ಸ್ವರೂಪದಲ್ಲಿ ದಿನಾಂಕಗಳ ಅರೇ ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ಅವುಗಳನ್ನು ವಿಭಿನ್ನ ಪ್ರಾದೇಶಿಕ ಆದ್ಯತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬೇಕಾಗಿದೆ ಎಂದು ಊಹಿಸಿ.

const dates = [
  '2024-01-15',
  '2023-12-24',
  '2024-02-01'
];

function formatDate(dateString, locale) {
  const date = new Date(dateString);
  return date.toLocaleDateString(locale);
}

function formatDates(dates, locale) {
  dates.forEach(dateString => {
    const formattedDate = formatDate(dateString, locale);
    console.log(`Formatted date (${locale}): ${formattedDate}`);
  });
}

formatDates(dates, 'en-US'); // US ಸ್ವರೂಪ
formatDates(dates, 'en-GB'); // UK ಸ್ವರೂಪ
formatDates(dates, 'de-DE'); // ಜರ್ಮನ್ ಸ್ವರೂಪ

map: ಅರೇಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು

map ಎನ್ನುವುದು ಅರೇಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಮತ್ತೊಂದು ಉನ್ನತ-ಕ್ರಮದ ಕಾರ್ಯವಾಗಿದೆ. ಇದು ಮೂಲ ಅರೇಯ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕೆ ಒದಗಿಸಿದ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಸಂಶ್ಲೇಷಣೆ ಮತ್ತು ಬಳಕೆ

map ನ ಸಂಶ್ಲೇಷಣೆಯು forEach ಗೆ ಹೋಲುತ್ತದೆ:

const newArray = array.map(function(element, index, array) {
  // ಪ್ರತಿ ಅಂಶವನ್ನು ಪರಿವರ್ತಿಸಲು ಕೋಡ್
  return transformedElement;
});

ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವು forEach ನಂತೆಯೇ ಮೂರು ವಾದಗಳನ್ನು (element, index, ಮತ್ತು array) ಸ್ವೀಕರಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಒಂದು ಮೌಲ್ಯವನ್ನು ಒದಗಿಸಬೇಕು, ಇದು ಹೊಸ ಅರೇಯಲ್ಲಿನ ಅನುಗುಣವಾದ ಅಂಶವಾಗಿರುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳು

forEach ಗೆ ಹೋಲಿಸಿದರೆ, ಕಾರ್ಯ ಕರೆ ಓವರ್‌ಹೆಡ್‌ನಿಂದಾಗಿ map ಸಾಮಾನ್ಯವಾಗಿ for ಲೂಪ್‌ಗಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, map ಒಂದು ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಸೇವಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಅರೇ ಅನ್ನು ಪರಿವರ್ತಿಸಬೇಕಾದ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ, map ಅನ್ನು for ಲೂಪ್‌ನೊಂದಿಗೆ ಹೊಸ ಅರೇ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ರಚಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು.

ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು:

• ಪರಿವರ್ತನೆ: ಪರಿವರ್ತಿತ ಅಂಶಗಳೊಂದಿಗೆ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ಡೇಟಾ ನಿರ್ವಹಣೆಗೆ ಸೂಕ್ತವಾಗಿದೆ.
• ಅಚಲತೆ: ಮೂಲ ಅರೇ ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ, ಅಚಲತೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
• ಚೈನಿಂಗ್: ಸಂಕೀರ್ಣ ಡೇಟಾ ಸಂಸ್ಕರಣೆಗಾಗಿ ಇತರ ಅರೇ ವಿಧಾನಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಸರಪಳಿಯನ್ನಾಗಿ ಮಾಡಬಹುದು.

ಪ್ರಮುಖ ಅನಾನುಕೂಲಗಳು:

• ನಿಧಾನ ಕಾರ್ಯಕ್ಷಮತೆ: ಸಾಮಾನ್ಯವಾಗಿ for ಲೂಪ್‌ಗಳಿಗಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ.
• ಮೆಮೊರಿ ಬಳಕೆ: ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.

ಉದಾಹರಣೆ: ವಿವಿಧ ದೇಶಗಳಿಂದ ಕರೆನ್ಸಿಗಳನ್ನು USD ಗೆ ಪರಿವರ್ತಿಸುವುದು

ನೀವು ವಿವಿಧ ಕರೆನ್ಸಿಗಳಲ್ಲಿ ವಹಿವಾಟುಗಳ ಅರೇ ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ವರದಿ ಮಾಡುವ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅವೆಲ್ಲವನ್ನೂ USD ಗೆ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ.

const transactions = [
  { id: 1, currency: 'EUR', amount: 100 },
  { id: 2, currency: 'GBP', amount: 50 },
  { id: 3, currency: 'JPY', amount: 7500 },
  { id: 4, currency: 'CAD', amount: 120 }
];

const exchangeRates = {
  'EUR': 1.10, // ಉದಾಹರಣೆ ವಿನಿಮಯ ದರ
  'GBP': 1.25,
  'JPY': 0.007,
  'CAD': 0.75
};

function convertToUSD(transaction) {
  const rate = exchangeRates[transaction.currency];
  if (rate) {
    return transaction.amount * rate;
  } else {
    return null; // ಪರಿವರ್ತನೆ ವೈಫಲ್ಯವನ್ನು ಸೂಚಿಸಿ
  }
}

const usdAmounts = transactions.map(transaction => convertToUSD(transaction));

console.log(usdAmounts);

ಕಾರ್ಯಕ್ಷಮತೆ ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್

ಈ ವಿಧಾನಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ವಸ್ತುನಿಷ್ಠವಾಗಿ ಹೋಲಿಸಲು, ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ console.time() ಮತ್ತು console.timeEnd() ಅಥವಾ ಮೀಸಲಾದ ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್ ಲೈಬ್ರರಿಗಳಂತಹ ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಬಹುದು. ಇಲ್ಲಿ ಮೂಲ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

const arraySize = 100000;
const largeArray = Array.from({ length: arraySize }, (_, i) => i + 1);

// ಫಾರ್ ಲೂಪ್
console.time('ಫಾರ್ ಲೂಪ್');
for (let i = 0; i < largeArray.length; i++) {
  // ಏನಾದರೂ ಮಾಡು
  largeArray[i] * 2;
}
console.timeEnd('ಫಾರ್ ಲೂಪ್');

// ಫೋರ್‌ಈಚ್
console.time('ಫೋರ್‌ಈಚ್');
largeArray.forEach(element => {
  // ಏನಾದರೂ ಮಾಡು
  element * 2;
});
console.timeEnd('ಫೋರ್‌ಈಚ್');

// ಮ್ಯಾಪ್
console.time('ಮ್ಯಾಪ್');
largeArray.map(element => {
  // ಏನಾದರೂ ಮಾಡು
  return element * 2;
});
console.timeEnd('ಮ್ಯಾಪ್');

ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು:

ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ಕಾರ್ಯಕ್ಷಮತೆ ಕ್ರಮವನ್ನು ಗಮನಿಸುವಿರಿ (ವೇಗದಿಂದ ನಿಧಾನಕ್ಕೆ):

1. for ಲೂಪ್
2. forEach
3. map

ಪ್ರಮುಖ ಪರಿಗಣನೆಗಳು:

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

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಬಳಕೆ ಪ್ರಕರಣಗಳು

ಸರಿಯಾದ ಪುನರಾವರ್ತನೆ ವಿಧಾನವನ್ನು ಆರಿಸುವುದು ನಿಮ್ಮ ಕಾರ್ಯದ ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಇಲ್ಲಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಸಾರಾಂಶ ಇಲ್ಲಿದೆ:

• ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಕಾರ್ಯಾಚರಣೆಗಳು: ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ವಿಶೇಷವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ for ಲೂಪ್‌ಗಳನ್ನು ಬಳಸಿ.
• ಸರಳ ಪುನರಾವರ್ತನೆ: ಕಾರ್ಯಕ್ಷಮತೆಯು ಒಂದು ಪ್ರಾಥಮಿಕ ಕಾಳಜಿಯಲ್ಲದಿದ್ದಾಗ ಮತ್ತು ಓದಬಲ್ಲದು ಮುಖ್ಯವಾದಾಗ ಸರಳ ಪುನರಾವರ್ತನೆಗಾಗಿ forEach ಅನ್ನು ಬಳಸಿ.
• ಅರೇ ಪರಿವರ್ತನೆ: ನೀವು ಒಂದು ಅರೇ ಅನ್ನು ಪರಿವರ್ತಿಸಬೇಕಾದಾಗ ಮತ್ತು ಪರಿವರ್ತಿತ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸಬೇಕಾದಾಗ map ಅನ್ನು ಬಳಸಿ.
• ಪುನರಾವರ್ತನೆಯನ್ನು ಮುರಿಯುವುದು ಅಥವಾ ಮುಂದುವರಿಸುವುದು: ನೀವು break ಅಥವಾ continue ಅನ್ನು ಬಳಸಬೇಕಾದರೆ, ನೀವು for ಲೂಪ್ ಅನ್ನು ಬಳಸಬೇಕು. forEach ಮತ್ತು map ಮುರಿಯಲು ಅಥವಾ ಮುಂದುವರಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ.
• ಅಚಲತೆ: ನೀವು ಮೂಲ ಅರೇ ಅನ್ನು ಸಂರಕ್ಷಿಸಲು ಮತ್ತು ಮಾರ್ಪಾಡುಗಳೊಂದಿಗೆ ಹೊಸದನ್ನು ರಚಿಸಲು ಬಯಸಿದಾಗ, map ಅನ್ನು ಬಳಸಿ.

ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳು

ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ವಿಧಾನವು ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ಕೆಲವು ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳು ಇಲ್ಲಿವೆ:

• ವೆಬ್‌ಸೈಟ್ ಟ್ರಾಫಿಕ್ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು (for ಲೂಪ್): ಪ್ರಮುಖ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಲಕ್ಷಾಂತರ ವೆಬ್‌ಸೈಟ್ ಟ್ರಾಫಿಕ್ ದಾಖಲೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ ಮತ್ತು ಅತ್ಯುತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಗತ್ಯವಿರುವುದರಿಂದ ಇಲ್ಲಿ for ಲೂಪ್ ಸೂಕ್ತವಾಗಿದೆ.
• ಉತ್ಪನ್ನಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವುದು (forEach): ಇ-ಕಾಮರ್ಸ್ ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಉತ್ಪನ್ನಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವುದು. ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮವು ಕಡಿಮೆಯಿರುವುದರಿಂದ ಮತ್ತು ಕೋಡ್ ಹೆಚ್ಚು ಓದಬಲ್ಲದಾಗಿರುವುದರಿಂದ ಇಲ್ಲಿ forEach ಸಾಕಾಗುತ್ತದೆ.
• ಬಳಕೆದಾರರ ಅವತಾರಗಳನ್ನು ರಚಿಸುವುದು (map): ಬಳಕೆದಾರರ ಡೇಟಾದಿಂದ ಬಳಕೆದಾರರ ಅವತಾರಗಳನ್ನು ರಚಿಸುವುದು, ಅಲ್ಲಿ ಪ್ರತಿ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಚಿತ್ರ URL ಗೆ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ. map ಪರಿಪೂರ್ಣ ಆಯ್ಕೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಅದು ಡೇಟಾವನ್ನು ಚಿತ್ರ URL ಗಳ ಹೊಸ ಅರೇಯಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
• ಲಾಗ್ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು (for ಲೂಪ್): ದೋಷಗಳು ಅಥವಾ ಭದ್ರತಾ ಬೆದರಿಕೆಗಳನ್ನು ಗುರುತಿಸಲು ಸಿಸ್ಟಮ್ ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು. ಲಾಗ್ ಫೈಲ್‌ಗಳು ತುಂಬಾ ದೊಡ್ಡದಾಗಿರಬಹುದು ಮತ್ತು ವಿಶ್ಲೇಷಣೆಯು ಕೆಲವು ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಲೂಪ್‌ನಿಂದ ಹೊರಬರಬೇಕಾಗಬಹುದು, ಆದ್ದರಿಂದ for ಲೂಪ್ ಸಾಮಾನ್ಯವಾಗಿ ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಆಯ್ಕೆಯಾಗಿದೆ.
• ಅಂತರರಾಷ್ಟ್ರೀಯ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು ಸ್ಥಳೀಕರಿಸುವುದು (map): ಅಂತರರಾಷ್ಟ್ರೀಯ ಬಳಕೆದಾರರಿಗೆ ಪ್ರದರ್ಶಿಸಲು ಡೇಟಾವನ್ನು ತಯಾರಿಸಲು, ವಿವಿಧ ಸ್ಥಳೀಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳ ಅರೇ ಅನ್ನು ಪರಿವರ್ತಿಸುವುದು. ಪರಿವರ್ತನೆ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಸ್ಥಳೀಕರಿಸಿದ ಸಂಖ್ಯೆ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸಲು map ಅನ್ನು ಬಳಸುವುದು ಮೂಲ ಡೇಟಾ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮೂಲ ಅಂಶಗಳನ್ನು ಮೀರಿದೆ: ಇತರ ಪುನರಾವರ್ತನೆ ವಿಧಾನಗಳು

ಈ ಲೇಖನವು for ಲೂಪ್‌ಗಳು, forEach ಮತ್ತು map ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದರೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇತರ ಪುನರಾವರ್ತನೆ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ ಅದು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಬಹುದು:

• for...of: ಪುನರಾವರ್ತಿಸಬಹುದಾದ ವಸ್ತುವಿನ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ (ಉದಾ., ಅರೇಗಳು, ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ನಕ್ಷೆಗಳು, ಸೆಟ್‌ಗಳು).
• for...in: ವಸ್ತುವಿನ ಎಣಿಸಬಹುದಾದ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. (ಪುನರಾವರ್ತನೆಯ ಕ್ರಮವು ಖಾತರಿಯಿಲ್ಲದ ಕಾರಣ ಮತ್ತು ಇದು ಆನುವಂಶಿಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸಹ ಒಳಗೊಂಡಿರುವುದರಿಂದ ಅರೇಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾಗುವುದಿಲ್ಲ).
• filter: ಒದಗಿಸಿದ ಕಾರ್ಯದಿಂದ ಜಾರಿಗೆ ತರಲಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾದ ಎಲ್ಲಾ ಅಂಶಗಳೊಂದಿಗೆ ಹೊಸ ಅರೇ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• reduce: ಅದನ್ನು ಒಂದೇ ಮೌಲ್ಯಕ್ಕೆ ಕಡಿಮೆ ಮಾಡಲು ಸಂಚಯಕ ಮತ್ತು ಅರೇಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಅಂಶದ ವಿರುದ್ಧ (ಎಡದಿಂದ ಬಲಕ್ಕೆ) ಒಂದು ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

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

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