M

MLOG

ಕನ್ನಡ

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್: ಆಧುನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಶಕ್ತಿಯುತ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ಗಳು ಎಂದರೇನು?

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

ಒಂದು ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಎನ್ನುವುದು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು, ಅದು ತನ್ನ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಅಸಮಕಾಲಿಕವಾಗಿ ಪುನರಾವರ್ತಿಸುವ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಇದು @@asyncIterator ಮೆಥಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡುತ್ತದೆ, ಇದು ಒಂದು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಒಂದು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಎನ್ನುವುದು next() ಮೆಥಡ್ ಅನ್ನು ಒದಗಿಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಈ ಮೆಥಡ್ ಒಂದು ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದು ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ರಿಸಾಲ್ವ್ ಆಗುತ್ತದೆ:

ಇಲ್ಲಿದೆ ಒಂದು ಸರಳ ಉದಾಹರಣೆ:


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅನುಕರಿಸಿ
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  for await (const value of asyncIterable) {
    console.log(value); // ಔಟ್‌ಪುಟ್: 1, 2, 3, 4, 5 (ಪ್ರತಿಯೊಂದರ ನಡುವೆ 500ms ವಿಳಂಬದೊಂದಿಗೆ)
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, generateSequence ಒಂದು ಅಸಿಂಕ್ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಅದು ಅಸಮಕಾಲಿಕವಾಗಿ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. for await...of ಲೂಪ್ ಅನ್ನು ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ಪರಿಚಯ

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

ಪ್ರಮುಖ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್‌ಗಳು ಇವುಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:

ಪ್ರತಿಯೊಂದು ಹೆಲ್ಪರ್ ಅನ್ನು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅನ್ವೇಷಿಸೋಣ.

map()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const doubledIterable = asyncIterable.map(x => x * 2);

(async () => {
  for await (const value of doubledIterable) {
    console.log(value); // ಔಟ್‌ಪುಟ್: 2, 4, 6, 8, 10 (100ms ವಿಳಂಬದೊಂದಿಗೆ)
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, map(x => x * 2) ಅನುಕ್ರಮದಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಸಂಖ್ಯೆಯನ್ನು ದ್ವಿಗುಣಗೊಳಿಸುತ್ತದೆ.

filter()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(10);

const evenNumbersIterable = asyncIterable.filter(x => x % 2 === 0);

(async () => {
  for await (const value of evenNumbersIterable) {
    console.log(value); // ಔಟ್‌ಪುಟ್: 2, 4, 6, 8, 10 (100ms ವಿಳಂಬದೊಂದಿಗೆ)
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, filter(x => x % 2 === 0) ಅನುಕ್ರಮದಿಂದ ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.

take()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const firstThreeIterable = asyncIterable.take(3);

(async () => {
  for await (const value of firstThreeIterable) {
    console.log(value); // ಔಟ್‌ಪುಟ್: 1, 2, 3 (100ms ವಿಳಂಬದೊಂದಿಗೆ)
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, take(3) ಅನುಕ್ರಮದಿಂದ ಮೊದಲ ಮೂರು ಸಂಖ್ಯೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.

drop()

drop() ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಿಂದ ಮೊದಲ N ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಬಿಟ್ಟು ಉಳಿದವುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಉಳಿದ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const afterFirstTwoIterable = asyncIterable.drop(2);

(async () => {
  for await (const value of afterFirstTwoIterable) {
    console.log(value); // ಔಟ್‌ಪುಟ್: 3, 4, 5 (100ms ವಿಳಂಬದೊಂದಿಗೆ)
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, drop(2) ಅನುಕ್ರಮದಿಂದ ಮೊದಲ ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

toArray()

toArray() ಹೆಲ್ಪರ್ ಸಂಪೂರ್ಣ ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಒಂದು ಅರೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದು ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಅರೇಗೆ ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const numbersArray = await asyncIterable.toArray();
  console.log(numbersArray); // ಔಟ್‌ಪುಟ್: [1, 2, 3, 4, 5]
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, toArray() ಅನುಕ್ರಮದಿಂದ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ಒಂದು ಅರೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

forEach()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(3);

(async () => {
  await asyncIterable.forEach(value => {
    console.log("Value:", value);
  });
  console.log("forEach completed");
})();
// ಔಟ್‌ಪುಟ್: Value: 1, Value: 2, Value: 3, forEach completed

some()

some() ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಲ್ಲಿನ ಕನಿಷ್ಠ ಒಂದು ಎಲಿಮೆಂಟ್ ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಮೂಲಕ ಜಾರಿಗೆ ತಂದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣವಾಗುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಇದು ಬೂಲಿಯನ್ ಮೌಲ್ಯಕ್ಕೆ (ಕನಿಷ್ಠ ಒಂದು ಎಲಿಮೆಂಟ್ ಷರತ್ತನ್ನು ಪೂರೈಸಿದರೆ true, ಇಲ್ಲದಿದ್ದರೆ false) ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const hasEvenNumber = await asyncIterable.some(x => x % 2 === 0);
  console.log("Has even number:", hasEvenNumber); // ಔಟ್‌ಪುಟ್: Has even number: true
})();

every()

every() ಹೆಲ್ಪರ್ ಅಸಿಂಕ್ ಇಟರೇಬಲ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳು ಒದಗಿಸಿದ ಫಂಕ್ಷನ್ ಮೂಲಕ ಜಾರಿಗೆ ತಂದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣವಾಗುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಇದು ಬೂಲಿಯನ್ ಮೌಲ್ಯಕ್ಕೆ (ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳು ಷರತ್ತನ್ನು ಪೂರೈಸಿದರೆ true, ಇಲ್ಲದಿದ್ದರೆ false) ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


async function* generateSequence(end) {
  for (let i = 2; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(4);

(async () => {
  const areAllEven = await asyncIterable.every(x => x % 2 === 0);
  console.log("Are all even:", areAllEven); // ಔಟ್‌ಪುಟ್: Are all even: true
})();

find()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const firstEven = await asyncIterable.find(x => x % 2 === 0);
  console.log("First even number:", firstEven); // ಔಟ್‌ಪುಟ್: First even number: 2
})();

reduce()

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


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const sum = await asyncIterable.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
  console.log("Sum:", sum); // ಔಟ್‌ಪುಟ್: Sum: 15
})();

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಮೌಲ್ಯಯುತವಾಗಿವೆ. ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

1. ಸ್ಟ್ರೀಮಿಂಗ್ API ನಿಂದ ಡೇಟಾವನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡುವುದು

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


async function* fetchDataFromAPI(url) {
  let response = await fetch(url);

  if (!response.body) {
    throw new Error("ReadableStream not supported in this environment");
  }

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      const chunk = decoder.decode(value);
      // API ಹೊಸ ಸಾಲುಗಳಿಂದ ಬೇರ್ಪಟ್ಟ JSON ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಎಂದು ಭಾವಿಸೋಣ
      const lines = chunk.split('\n');
      for (const line of lines) {
        if (line.trim() !== '') {
          yield JSON.parse(line);
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

const apiURL = 'https://example.com/streaming-api'; // ನಿಮ್ಮ API URL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ
const dataStream = fetchDataFromAPI(apiURL);

// ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
(async () => {
  for await (const data of dataStream.filter(item => item.type === 'metric').map(item => ({ timestamp: item.timestamp, value: item.value }))) {
    console.log('Processed Data:', data);
    // ಪ್ರೊಸೆಸ್ ಮಾಡಿದ ಡೇಟಾದೊಂದಿಗೆ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಿ
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, fetchDataFromAPI ಸ್ಟ್ರೀಮಿಂಗ್ API ನಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತದೆ, JSON ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಆಗಿ ನೀಡುತ್ತದೆ. filter ಹೆಲ್ಪರ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಮಾತ್ರ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು map ಹೆಲ್ಪರ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡುವ ಮೊದಲು ಡೇಟಾವನ್ನು ಅಪೇಕ್ಷಿತ ಸ್ವರೂಪಕ್ಕೆ ರೂಪಾಂತರಿಸುತ್ತದೆ.

2. ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಓದುವುದು ಮತ್ತು ಪ್ರೊಸೆಸ್ ಮಾಡುವುದು

ನೀವು ಗ್ರಾಹಕರ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ದೊಡ್ಡ CSV ಫೈಲ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಬೇಕಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು, ನೀವು ಅದನ್ನು ಚಂಕ್-ಬೈ-ಚಂಕ್ ಆಗಿ ಪ್ರೊಸೆಸ್ ಮಾಡಲು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು.


async function* readLinesFromFile(filePath) {
  const file = await fsPromises.open(filePath, 'r');

  try {
    let buffer = Buffer.alloc(1024);
    let fileOffset = 0;
    let remainder = '';

    while (true) {
      const { bytesRead } = await file.read(buffer, 0, buffer.length, fileOffset);
      if (bytesRead === 0) {
        if (remainder) {
          yield remainder;
        }
        break;
      }

      fileOffset += bytesRead;
      const chunk = buffer.toString('utf8', 0, bytesRead);
      const lines = chunk.split('\n');

      lines[0] = remainder + lines[0];
      remainder = lines.pop() || '';

      for (const line of lines) {
        yield line;
      }
    }
  } finally {
    await file.close();
  }
}

const filePath = './customer_data.csv'; // ನಿಮ್ಮ ಫೈಲ್ ಪಾತ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ
const lines = readLinesFromFile(filePath);

// ಸಾಲುಗಳನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
(async () => {
  for await (const customerData of lines.drop(1).map(line => line.split(',')).filter(data => data[2] === 'USA')) {
    console.log('Customer from USA:', customerData);
    // USA ಯಿಂದ ಗ್ರಾಹಕರ ಡೇಟಾವನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, readLinesFromFile ಫೈಲ್ ಅನ್ನು ಸಾಲು-ಸಾಲು ಓದುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಸಾಲನ್ನು ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಆಗಿ ನೀಡುತ್ತದೆ. drop(1) ಹೆಲ್ಪರ್ ಹೆಡರ್ ಸಾಲನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ, map ಹೆಲ್ಪರ್ ಸಾಲನ್ನು ಕಾಲಮ್‌ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ, ಮತ್ತು filter ಹೆಲ್ಪರ್ USA ಯಿಂದ ಗ್ರಾಹಕರನ್ನು ಮಾತ್ರ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.

3. ನೈಜ-ಸಮಯದ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳಂತಹ ಮೂಲಗಳಿಂದ ನೈಜ-ಸಮಯದ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು. ನೀವು ಈವೆಂಟ್‌ಗಳು ಬಂದಂತೆ ಅವುಗಳನ್ನು ಹೊರಸೂಸುವ ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಅನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ನಂತರ ಈ ಈವೆಂಟ್‌ಗಳನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಲು ಹೆಲ್ಪರ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು.


async function* createWebSocketStream(url) {
  const ws = new WebSocket(url);

  yield new Promise((resolve, reject) => {
      ws.onopen = () => {
          resolve();
      };
      ws.onerror = (error) => {
          reject(error);
      };
  });

  try {
    while (ws.readyState === WebSocket.OPEN) {
      yield new Promise((resolve, reject) => {
        ws.onmessage = (event) => {
          resolve(JSON.parse(event.data));
        };
        ws.onerror = (error) => {
          reject(error);
        };
        ws.onclose = () => {
           resolve(null); // ಸಂಪರ್ಕ ಮುಚ್ಚಿದಾಗ null ನೊಂದಿಗೆ ರಿಸಾಲ್ವ್ ಮಾಡಿ
        }
      });

    }
  } finally {
    ws.close();
  }
}

const websocketURL = 'wss://example.com/events'; // ನಿಮ್ಮ ವೆಬ್‌ಸಾಕೆಟ್ URL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ
const eventStream = createWebSocketStream(websocketURL);

// ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
(async () => {
  for await (const event of eventStream.filter(event => event.type === 'user_login').map(event => ({ userId: event.userId, timestamp: event.timestamp }))) {
    console.log('User Login Event:', event);
    // ಬಳಕೆದಾರ ಲಾಗಿನ್ ಈವೆಂಟ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
  }
})();

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

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

ಬ್ರೌಸರ್ ಮತ್ತು ರನ್‌ಟೈಮ್ ಬೆಂಬಲ

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

ಬ್ರೌಸರ್ ಬೆಂಬಲ: Chrome, Firefox, Safari, ಮತ್ತು Edge ನಂತಹ ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳು ಕ್ರಮೇಣ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್‌ಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸುತ್ತಿವೆ. ಈ ಫೀಚರ್ ಅನ್ನು ಯಾವ ಬ್ರೌಸರ್‌ಗಳು ಬೆಂಬಲಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡಲು Can I use... ನಂತಹ ವೆಬ್‌ಸೈಟ್‌ಗಳಲ್ಲಿ ಇತ್ತೀಚಿನ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯ ಮಾಹಿತಿಯನ್ನು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು.

Node.js ಬೆಂಬಲ: Node.js ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳು (v18 ಮತ್ತು ಮೇಲ್ಪಟ್ಟು) ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್‌ಗೆ ಪ್ರಾಯೋಗಿಕ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ಬಳಸಲು, ನೀವು --experimental-async-iterator ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ Node.js ಅನ್ನು ರನ್ ಮಾಡಬೇಕಾಗಬಹುದು.

ಪಾಲಿಫಿಲ್‌ಗಳು: ಅವುಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಬೆಂಬಲಿಸದ ಪರಿಸರದಲ್ಲಿ ನೀವು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ಅನ್ನು ಬಳಸಬೇಕಾದರೆ, ನೀವು ಪಾಲಿಫಿಲ್ ಅನ್ನು ಬಳಸಬಹುದು. ಪಾಲಿಫಿಲ್ ಎನ್ನುವುದು ಕಾಣೆಯಾದ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುವ ಕೋಡ್‌ನ ಒಂದು ತುಣುಕು. ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್‌ಗಾಗಿ ಹಲವಾರು ಪಾಲಿಫಿಲ್ ಲೈಬ್ರರಿಗಳು ಲಭ್ಯವಿದೆ; ಒಂದು ಜನಪ್ರಿಯ ಆಯ್ಕೆ core-js ಲೈಬ್ರರಿ.

ಕಸ್ಟಮ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

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

ಕಸ್ಟಮ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸಲು, ನೀವು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಮೇಲೆ @@asyncIterator ಮೆಥಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು. ಈ ಮೆಥಡ್ next() ಮೆಥಡ್ ಇರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು. next() ಮೆಥಡ್ value ಮತ್ತು done ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

ಪೇಜಿನೇಟೆಡ್ API ನಿಂದ ಡೇಟಾವನ್ನು ತರುವ ಕಸ್ಟಮ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:


async function* fetchPaginatedData(baseURL) {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const url = `${baseURL}?page=${page}`;
    const response = await fetch(url);
    const data = await response.json();

    if (data.results.length === 0) {
      hasMore = false;
      break;
    }

    for (const item of data.results) {
      yield item;
    }

    page++;
  }
}

const apiBaseURL = 'https://api.example.com/data'; // ನಿಮ್ಮ API URL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ
const paginatedData = fetchPaginatedData(apiBaseURL);

// ಪೇಜಿನೇಟೆಡ್ ಡೇಟಾವನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
(async () => {
  for await (const item of paginatedData) {
    console.log('Item:', item);
    // ಐಟಂ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಿ
  }
})();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, fetchPaginatedData ಪೇಜಿನೇಟೆಡ್ API ನಿಂದ ಡೇಟಾವನ್ನು ತರುತ್ತದೆ, ಪ್ರತಿ ಐಟಂ ಅನ್ನು ಹಿಂಪಡೆದಂತೆ ನೀಡುತ್ತದೆ. ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಪೇಜಿನೇಷನ್ ಲಾಜಿಕ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ರೀತಿಯಲ್ಲಿ ಬಳಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

ಸಂಭಾವ್ಯ ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್ ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಸ್‌ನಿಂದ ಹೆಚ್ಚಿನದನ್ನು ಪಡೆಯಲು, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

ಸುಧಾರಿತ ತಂತ್ರಗಳು

ಕಸ್ಟಮ್ ಹೆಲ್ಪರ್ಸ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

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


async function* takeWhile(asyncIterable, predicate) {
  for await (const value of asyncIterable) {
    if (!predicate(value)) {
      break;
    }
    yield value;
  }
}

// ಬಳಕೆಯ ಉದಾಹರಣೆ:
async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(10);
const firstFive = takeWhile(asyncIterable, x => x <= 5);

(async () => {
  for await (const value of firstFive) {
    console.log(value);
  }
})();

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

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


async function* zip(asyncIterable1, asyncIterable2) {
    const iterator1 = asyncIterable1[Symbol.asyncIterator]();
    const iterator2 = asyncIterable2[Symbol.asyncIterator]();

    while (true) {
        const result1 = await iterator1.next();
        const result2 = await iterator2.next();

        if (result1.done || result2.done) {
            break;
        }

        yield [result1.value, result2.value];
    }
}

// ಬಳಕೆಯ ಉದಾಹರಣೆ:
async function* generateSequence1(end) {
    for (let i = 1; i <= end; i++) {
        yield i;
    }
}

async function* generateSequence2(end) {
    for (let i = 10; i <= end + 9; i++) {
        yield i;
    }
}

const iterable1 = generateSequence1(5);
const iterable2 = generateSequence2(5);

(async () => {
    for await (const [value1, value2] of zip(iterable1, iterable2)) {
        console.log(value1, value2);
    }
})();

ತೀರ್ಮಾನ

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