ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್: ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಎಂದರೇನು?

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಒಂದು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಸ್ಟ್ರೀಮ್‌ಗಳು ಅಥವಾ ಅಸಮಕಾಲಿಕ API ಪ್ರತಿಕ್ರಿಯೆಗಳಂತಹ ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಮೂಲಗಳ ಮೇಲೆ ನಿಯಂತ್ರಿತ ಮತ್ತು ಅನುಕ್ರಮವಾದ ರೀತಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅವು ಸಾಮಾನ್ಯ ಇಟರೇಟರ್‌ಗಳಂತೆಯೇ ಇರುತ್ತವೆ, ಆದರೆ ಅವುಗಳ next() ಮೆಥಡ್ ಒಂದು ಪ್ರಾಮಿಸ್ (Promise) ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂಬುದು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವಾಗಿದೆ. ಇದು ಮುಖ್ಯ ಥ್ರೆಡ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸದೆ ಅಸಮಕಾಲಿಕವಾಗಿ ಬರುವ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

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

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

• ಅಸಿಂಕ್ ಇಟರೇಟರ್: ಸಾಮಾನ್ಯ ಇಟರೇಟರ್‌ನಂತೆಯೇ value ಮತ್ತು done ಗುಣಲಕ್ಷಣಗಳಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ next() ಮೆಥಡ್ ಅನ್ನು ಒದಗಿಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್. value ಅನುಕ್ರಮದಲ್ಲಿ ಮುಂದಿನ ಐಟಂ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು done ಪುನರಾವರ್ತನೆ ಪೂರ್ಣಗೊಂಡಿದೆಯೇ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.
• ಅಸಿಂಕ್ ಜನರೇಟರ್: ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಫಂಕ್ಷನ್. ಇದು ಅಸಮಕಾಲಿಕವಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ಉತ್ಪಾದಿಸಲು yield ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
• for await...of ಲೂಪ್: ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಭಾಷಾ ರಚನೆ. ಇದು ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳೊಂದಿಗೆ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ರಚಿಸುವುದು

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಅತಿ ಸಾಮಾನ್ಯವಾದ ಮಾರ್ಗವೆಂದರೆ ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳ ಮೂಲಕ. ಅಸಿಂಕ್ ಜನರೇಟರ್ ಎನ್ನುವುದು async function* ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ ಘೋಷಿಸಲಾದ ಫಂಕ್ಷನ್. ಫಂಕ್ಷನ್‌ನೊಳಗೆ, ನೀವು ಅಸಮಕಾಲಿಕವಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ಉತ್ಪಾದಿಸಲು yield ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ: ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್ ಅನ್ನು ಅನುಕರಿಸುವುದು

ಸ್ಟಾಕ್ ಬೆಲೆಗಳು ಅಥವಾ ಸೆನ್ಸರ್ ರೀಡಿಂಗ್‌ಗಳಂತಹ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್ ಅನ್ನು ಅನುಕರಿಸುವ ಅಸಿಂಕ್ ಜನರೇಟರ್ ಅನ್ನು ರಚಿಸೋಣ. ನಾವು ಕೃತಕ ವಿಳಂಬಗಳನ್ನು ಪರಿಚಯಿಸಲು ಮತ್ತು ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಆಗಮನವನ್ನು ಅನುಕರಿಸಲು setTimeout ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

            async function* generateDataFeed(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate delay
    yield { timestamp: Date.now(), value: Math.random() * 100 };
  }
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• async function* generateDataFeed(count) ಎಷ್ಟು ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಬೇಕು ಎಂದು ಸೂಚಿಸುವ count ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಅಸಿಂಕ್ ಜನರೇಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ.
• for ಲೂಪ್ count ಬಾರಿ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
• await new Promise(resolve => setTimeout(resolve, 500)) setTimeout ಬಳಸಿ 500ms ವಿಳಂಬವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಇದು ನೈಜ-ಸಮಯದ ಡೇಟಾ ಆಗಮನದ ಅಸಮಕಾಲಿಕ ಸ್ವರೂಪವನ್ನು ಅನುಕರಿಸುತ್ತದೆ.
• yield { timestamp: Date.now(), value: Math.random() * 100 } ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ. yield ಕೀವರ್ಡ್ ಫಂಕ್ಷನ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಕಾಲರ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

for await...of ಮೂಲಕ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ಬಳಸಲು, ನೀವು for await...of ಲೂಪ್ ಅನ್ನು ಬಳಸಬಹುದು. ಈ ಲೂಪ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಟರೇಟರ್‌ನ ಅಸಮಕಾಲಿಕ ಸ್ವರೂಪವನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ, ಪ್ರತಿ ಪ್ರಾಮಿಸ್ ರಿಸಾಲ್ವ್ ಆಗುವವರೆಗೆ ಕಾಯ್ದು ನಂತರ ಮುಂದಿನ ಪುನರಾವರ್ತನೆಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.

ಉದಾಹರಣೆ: ಡೇಟಾ ಫೀಡ್ ಅನ್ನು ಸಂಸ್ಕರಿಸುವುದು

generateDataFeed ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು for await...of ಲೂಪ್ ಬಳಸಿ ಬಳಸೋಣ ಮತ್ತು ಪ್ರತಿ ಡೇಟಾ ಪಾಯಿಂಟ್ ಅನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡೋಣ.

            async function processDataFeed() {
  for await (const data of generateDataFeed(5)) {
    console.log(`Received data: ${JSON.stringify(data)}`);
  }
  console.log('Data feed processing complete.');
}

processDataFeed();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• async function processDataFeed() ಡೇಟಾ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಅಸಮಕಾಲಿಕ ಫಂಕ್ಷನ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ.
• for await (const data of generateDataFeed(5)) generateDataFeed(5) ನಿಂದ ಹಿಂತಿರುಗಿದ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. await ಕೀವರ್ಡ್ ಪ್ರತಿ ಡೇಟಾ ಪಾಯಿಂಟ್ ಬರುವವರೆಗೆ ಲೂಪ್ ಕಾಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• console.log(`Received data: ${JSON.stringify(data)}`) ಸ್ವೀಕರಿಸಿದ ಡೇಟಾ ಪಾಯಿಂಟ್ ಅನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ.
• console.log('Data feed processing complete.') ಡೇಟಾ ಫೀಡ್ ಸಂಸ್ಕರಣೆ ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂದು ಸೂಚಿಸುವ ಸಂದೇಶವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್, ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಮತ್ತು ಪ್ರಾಮಿಸ್‌ಗಳಂತಹ ಸಾಂಪ್ರದಾಯಿಕ ಅಸಮಕಾಲಿಕ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ತಂತ್ರಗಳಿಗಿಂತ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ:

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

ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ವಿವಿಧ ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಿಗೆ ಸೂಕ್ತವಾಗಿವೆ, ಅವುಗಳೆಂದರೆ:

• API ಸ್ಟ್ರೀಮಿಂಗ್: ಸ್ಟ್ರೀಮಿಂಗ್ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಬೆಂಬಲಿಸುವ API ಗಳಿಂದ ಡೇಟಾವನ್ನು ಬಳಸುವುದು (ಉದಾ., ಸರ್ವರ್-ಸೆಂಟ್ ಈವೆಂಟ್ಸ್, ವೆಬ್‌ಸಾಕೆಟ್ಸ್).
• ಫೈಲ್ ಪ್ರೊಸೆಸಿಂಗ್: ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆ ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ತುಣುಕುಗಳಲ್ಲಿ ಓದುವುದು. ಉದಾಹರಣೆಗೆ, ದೊಡ್ಡ CSV ಫೈಲ್ ಅನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಸಂಸ್ಕರಿಸುವುದು.
• ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್ಸ್: ಸ್ಟಾಕ್ ಎಕ್ಸ್‌ಚೇಂಜ್‌ಗಳು, ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು, ಅಥವಾ IoT ಸಾಧನಗಳಂತಹ ಮೂಲಗಳಿಂದ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಸಂಸ್ಕರಿಸುವುದು.
• ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳು: ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳಿಂದ ದೊಡ್ಡ ಫಲಿತಾಂಶ ಸೆಟ್‌ಗಳ ಮೇಲೆ ಸಮರ್ಥವಾಗಿ ಪುನರಾವರ್ತಿಸುವುದು.
• ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳು: ತುಣುಕುಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ದೀರ್ಘಕಾಲೀನ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.

ಉದಾಹರಣೆ: ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ತುಣುಕುಗಳಲ್ಲಿ ಓದುವುದು

ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ತುಣುಕುಗಳಲ್ಲಿ ಓದಲು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ಪ್ರದರ್ಶಿಸೋಣ, ಪ್ರತಿ ತುಣುಕು ಲಭ್ಯವಾದಂತೆ ಅದನ್ನು ಸಂಸ್ಕರಿಸುವುದು. ಮೆಮೊರಿಗೆ ಹಿಡಿಸಲಾಗದಷ್ಟು ದೊಡ್ಡದಾದ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

            const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readLines(filePath)) {
    // Process each line here
    console.log(`Line: ${line}`);
  }
}

processFile('large_file.txt');

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• ಫೈಲ್ ಅನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಓದಲು ನಾವು fs ಮತ್ತು readline ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.
• readLines ಅಸಿಂಕ್ ಜನರೇಟರ್ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಓದಲು readline.Interface ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• for await...of ಲೂಪ್ ಫೈಲ್‌ನಲ್ಲಿನ ಸಾಲುಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಪ್ರತಿ ಸಾಲನ್ನು ಕಾಲರ್‌ಗೆ ನೀಡುತ್ತದೆ.
• processFile ಫಂಕ್ಷನ್ readLines ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಸಾಲನ್ನು ಸಂಸ್ಕರಿಸುತ್ತದೆ.

ಈ ವಿಧಾನವು ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆ ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಸಂಸ್ಕರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ಸಮರ್ಥ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಆಗಿಸುತ್ತದೆ.

ಮುಂದುವರಿದ ತಂತ್ರಗಳು

ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ನಿರ್ವಹಣೆ

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

ಗ್ರಾಹಕರಿಗೆ ಇಟರೇಟರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ವಿನಂತಿಸುವ ದರವನ್ನು ನಿಯಂತ್ರಿಸಲು ಅನುಮತಿಸುವ ಮೂಲಕ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ನಂತರ ಉತ್ಪಾದಕರು ಗ್ರಾಹಕರ ವಿನಂತಿಗಳ ಆಧಾರದ ಮೇಲೆ ತಮ್ಮ ಡೇಟಾ ಉತ್ಪಾದನಾ ದರವನ್ನು ಸರಿಹೊಂದಿಸಬಹುದು.

ರದ್ದತಿ

ರದ್ದತಿ ಎಂದರೆ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಯು ಪೂರ್ಣಗೊಳ್ಳುವ ಮೊದಲು ಅದನ್ನು ನಿಲ್ಲಿಸುವ ಸಾಮರ್ಥ್ಯ. ಕಾರ್ಯಾಚರಣೆಯು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಲ್ಲಿ ಅಥವಾ ಪೂರ್ಣಗೊಳ್ಳಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ರದ್ದತಿಯನ್ನು ಬೆಂಬಲಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು, ಇದು ಗ್ರಾಹಕರಿಗೆ ಡೇಟಾ ಉತ್ಪಾದಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಬೇಕೆಂದು ಇಟರೇಟರ್‌ಗೆ ಸಂಕೇತಿಸಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಂತರ ಇಟರೇಟರ್ ಯಾವುದೇ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಬಹುದು ಮತ್ತು ಸರಿಯಾಗಿ ಅಂತ್ಯಗೊಳ್ಳಬಹುದು.

ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್ ವರ್ಸಸ್ ರಿಯಾಕ್ಟಿವ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್ (RxJS)

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

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ವರ್ಸಸ್ RxJS ಯಾವಾಗ ಬಳಸಬೇಕು

• ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಬಳಸಿ ಯಾವಾಗ:
  • ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಸರಳ ಮತ್ತು ಹಗುರವಾದ ಮಾರ್ಗ ಬೇಕಾದಾಗ.
  • ರಿಯಾಕ್ಟಿವ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್‌ನ ಸಂಪೂರ್ಣ ಶಕ್ತಿ ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ.
  • ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ನೀವು ಬಯಸಿದಾಗ.
  • ಅನುಕ್ರಮ ಮತ್ತು ನಿಯಂತ್ರಿತ ರೀತಿಯಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಡೇಟಾದೊಂದಿಗೆ ನೀವು ಕೆಲಸ ಮಾಡಬೇಕಾದಾಗ.
• RxJS ಬಳಸಿ ಯಾವಾಗ:
  • ಅತ್ಯಾಧುನಿಕ ಡೇಟಾ ರೂಪಾಂತರಗಳು ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಸಂಕೀರ್ಣ ರಿಯಾಕ್ಟಿವ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನೀವು ನಿರ್ಮಿಸಬೇಕಾದಾಗ.
  • ಏಕಕಾಲೀನತೆ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ರೀತಿಯಲ್ಲಿ ನೀವು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ.
  • ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಶ್ರೀಮಂತ ಆಪರೇಟರ್‌ಗಳ ಸೆಟ್ ಅಗತ್ಯವಿದ್ದಾಗ.
  • ನೀವು ಈಗಾಗಲೇ ರಿಯಾಕ್ಟಿವ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದಾಗ.

ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಪಾಲಿಫಿಲ್‌ಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್ ಎಲ್ಲಾ ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು Node.js ಆವೃತ್ತಿಗಳಲ್ಲಿ ಬೆಂಬಲಿತವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ನೀವು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳು ಅಥವಾ ಪರಿಸರಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕಾದರೆ, ನೀವು ಪಾಲಿಫಿಲ್ ಅನ್ನು ಬಳಸಬೇಕಾಗಬಹುದು.

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್‌ಗಾಗಿ ಹಲವಾರು ಪಾಲಿಫಿಲ್‌ಗಳು ಲಭ್ಯವಿದೆ, ಅವುಗಳೆಂದರೆ:

• core-js: ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್‌ಗೆ ಬೆಂಬಲವನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಸಮಗ್ರ ಪಾಲಿಫಿಲ್ ಲೈಬ್ರರಿ.
• regenerator-runtime: ರೀಜನರೇಟರ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುವ ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್‌ಗಾಗಿ ಒಂದು ಪಾಲಿಫಿಲ್.

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

ತೀರ್ಮಾನ

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್ಸ್‌ನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಮತ್ತು for await...of ಲೂಪ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನ ಶಕ್ತಿಯನ್ನು ನೀವು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್‌ಗಳ ಸಂಗ್ರಹಕ್ಕಾಗಿ it-tools (https://www.npmjs.com/package/it-tools) ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ಹೆಚ್ಚಿನ ಅನ್ವೇಷಣೆ

• MDN Web Docs: for await...of
• TC39 Proposal: Async Iteration