ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಸಿಂಕ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು / ನಿರೀಕ್ಷಿಸಿ: ಔಟ್‌ಪುಟ್ ಟೈಮಿಂಗ್‌ಗಳಿಗೆ ಆಳವಾದ ಡೈವ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಅನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುವುದು/ಟೈಮಿಂಗ್‌ನಲ್ಲಿ ವರ್ತನೆಯನ್ನು ನಿರೀಕ್ಷಿಸಿ

ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ಅಸಿಂಕ್ / ನಿರೀಕ್ಷಿಸಿ ಅಸಮಕಾಲಿಕ ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಅತ್ಯಗತ್ಯ ಸಾಧನವಾಗಿದೆ. ಅದರ ಉಪಯುಕ್ತತೆಯ ಹೊರತಾಗಿಯೂ, ಈ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗಳಲ್ಲಿ ಔಟ್‌ಪುಟ್‌ಗಳ ನಿಖರವಾದ ಸಮಯವನ್ನು ಊಹಿಸಲು ಬಂದಾಗ ಅನೇಕ ಅಭಿವರ್ಧಕರು ಗೊಂದಲವನ್ನು ಎದುರಿಸುತ್ತಾರೆ. ಅಡಾಫೇಸ್‌ನಿಂದ ಮಾಡಲಾದ ಕೋಡಿಂಗ್ ಮೌಲ್ಯಮಾಪನಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಸತ್ಯವಾಗಿದೆ, ಅಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ಹರಿವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

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

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

ಮೊದಲ ಫಂಕ್ಷನ್ ಔಟ್‌ಪುಟ್ ಏಕೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕೋಡ್‌ಗೆ ಧುಮುಕೋಣ 24 5 ಸೆಕೆಂಡುಗಳ ನಂತರ, ಮತ್ತು ಎರಡನೇ ಕಾರ್ಯವು ಸಹ ಔಟ್ಪುಟ್ ಆಗುತ್ತದೆ 24 ಆದರೆ ವಿಭಿನ್ನ ಭರವಸೆಯ ರಚನೆಯೊಂದಿಗೆ. ಈ ಜ್ಞಾನದೊಂದಿಗೆ, ನಿಮ್ಮ ಮುಂಬರುವ ಸಂದರ್ಶನದ ಮೌಲ್ಯಮಾಪನಗಳಿಗೆ ನೀವು ಉತ್ತಮವಾಗಿ ಸಜ್ಜಾಗುತ್ತೀರಿ.

JavaScript ನಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

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

ಮೊದಲ ಕಾರ್ಯದಲ್ಲಿ, ಬಹು (ಇನ್ಪುಟ್), ಎರಡು ಭರವಸೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಕೋಡ್ ಅನುಕ್ರಮವಾಗಿ ಕಾಯುತ್ತದೆ. ದಿ ನಿರೀಕ್ಷಿಸಿ ಭರವಸೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವವರೆಗೆ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಎಂದು ಕೀವರ್ಡ್ ಖಚಿತಪಡಿಸುತ್ತದೆ ನಂತರ 5 ಸೆ(3) ಪರಿಹರಿಸಲಾಗಿದೆ. ನಂತರ, ಮೊದಲ ಭರವಸೆಯನ್ನು ಪರಿಹರಿಸಿದ ನಂತರ, ಕೋಡ್ ಎರಡನೇ ಭರವಸೆಗಾಗಿ ಮತ್ತೊಂದು 5 ಸೆಕೆಂಡುಗಳ ಕಾಲ ಕಾಯುತ್ತದೆ ನಂತರ 5 ಸೆ(4) ಪರಿಹರಿಸಲು. ಲೆಕ್ಕಾಚಾರವನ್ನು ಮಾಡುವ ಮೊದಲು ಇದು ಒಟ್ಟು 10 ಸೆಕೆಂಡುಗಳ ಕಾಲ ಕಾಯುವ ಸಮಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಪರಿಹರಿಸಿದ ಎರಡೂ ಮೌಲ್ಯಗಳಿಂದ ಇನ್ಪುಟ್ನ ಗುಣಾಕಾರವು ಅಂತಿಮ ಔಟ್ಪುಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ.

ಎರಡನೇ ಕಾರ್ಯ, second_mult(ಇನ್‌ಪುಟ್), ಎರಡೂ ಭರವಸೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ನಿಯೋಜಿಸುವ ಮೂಲಕ ನಂತರ 5 ಸೆ(3) ಮತ್ತು ನಂತರ 5 ಸೆ(4) ಅನ್ವಯಿಸುವ ಮೊದಲು ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ನಿರೀಕ್ಷಿಸಿ, ಎರಡೂ ಭರವಸೆಗಳು ಸಮಾನಾಂತರವಾಗಿ ನಡೆಯುತ್ತವೆ. ಕೋಡ್ ತಲುಪಿದಾಗ ನಿರೀಕ್ಷಿಸಿ ಹೇಳಿಕೆಗಳು, ಎರಡೂ ಭರವಸೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಇದು ಕಾಯುತ್ತಿದೆ, ಆದರೆ ಅವು ಈಗಾಗಲೇ ಪ್ರಗತಿಯಲ್ಲಿವೆ, ಒಟ್ಟು ಕಾಯುವ ಸಮಯವನ್ನು ಕೇವಲ 5 ಸೆಕೆಂಡುಗಳಿಗೆ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಈ ಏಕಕಾಲಿಕ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ.

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

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// First approach using async/await with sequential waits
async function mult(input) {
  const f = await after5s(3);
  const g = await after5s(4);
  return input * f * g;
}

// Calling the function and handling the promise resolution
mult(2).then(value => {
  console.log(value); // Output: 24 after 10 seconds
});

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// Second approach optimizing by starting both promises concurrently
async function second_mult(input) {
  const f = after5s(3); // Starts promise immediately
  const g = after5s(4); // Starts second promise concurrently
  return input * await f * await g;
}

// Calling the function and handling the promise resolution
second_mult(2).then(value => {
  console.log(value); // Output: 24 after 5 seconds
});

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಮಾದರಿಗಳನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದು

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

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

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