As we navigate the world of JavaScript, understanding its asynchronous nature is vital for building responsive web applications. While Promises are a great tool, they often fall short for more complex scenarios. In this post, we’ll delve into advanced asynchronous patterns that will elevate your JavaScript skills.
Generators and Yield for Async Control
Generators are a special type of function that allow you to pause execution and return intermediate results. This can be particularly useful for controlling asynchronous flows.
Example:
function* asyncGenerator() {
const data1 = yield fetchData1(); // Pause until data1 is available
const data2 = yield fetchData2(data1); // Pause until data2 is available
return processData(data1, data2); // Final processing
}
const generator = asyncGenerator();
async function handleAsync() {
const result1 = await generator.next(); // Fetch first data
const result2 = await generator.next(result1.value); // Fetch second data
const finalResult = await generator.next(result2.value); // Process final result
console.log(finalResult.value);
}
handleAsync();
Async Iterators
Async Iterators enable handling streams of asynchronous data efficiently, allowing you to process data as it arrives without blocking the main thread.
Example:
async function* fetchAPIData(url) {
const response = await fetch(url);
const data = await response.json();
for (const item of data) {
yield item; // Yield each item as it arrives
}
}
async function processAPIData() {
for await (const item of fetchAPIData('https://api.example.com/data')) {
console.log(item); // Process each item as it comes
}
}
processAPIData();
Concurrency with Promise.allSettled
Promise.allSettled allows you to wait for all Promises to settle, regardless of their outcome (resolved or rejected). This is useful for scenarios where you want to perform actions based on the results of multiple asynchronous operations.
Example:
const promise1 = Promise.resolve(1);
const promise2 = Promise.reject(new Error('Failed'));
const promise3 = Promise.resolve(3);
Promise.allSettled([promise1, promise2, promise3]).then((results) => {
results.forEach((result) => {
if (result.status === 'fulfilled') {
console.log('Result:', result.value);
} else {
console.error('Error:', result.reason);
}
});
});
Web Workers
Web Workers provide a way to run JavaScript in background threads, allowing for CPU-intensive tasks to be handled without freezing the UI. This is crucial for maintaining a smooth user experience in your applications.
Example:
// worker.js
self.onmessage = function(e) {
const result = heavyComputation(e.data); // Perform heavy computation
self.postMessage(result); // Send the result back to the main thread
};
// main.js
const worker = new Worker('worker.js');
worker.onmessage = function(e) {
console.log('Result from worker:', e.data);
};
// Start the worker with data
worker.postMessage(inputData);
At the end
Mastering these advanced asynchronous patterns will empower you to write more efficient, maintainable, and responsive JavaScript code. By incorporating Generators, Async Iterators, Promise.allSettled, and Web Workers, you can significantly improve the performance and user experience of your applications. Embrace these techniques and watch your JavaScript skills soar!
My personal website: https://shafayet.zya.me
A meme for you😉
Top comments (9)
Thanks for posting! I love to see interesting topics like this!
I'm having some trouble with the Async Iterators example, though. It contains the comment
// Process each item as it comesbut the way the generator function is written the data is fetched ahead of time and available all at once whenawait response.json()runs, before the firstyield. While we canyieldeach item, it isn't meaningfully async at that point.If the generator made a series of different network requests, that would be more realistically async iteration over the data:
This way, the
for awaitloop in the caller is in control of the asynchronous fetching of data.Thank you for bringing this up! You’ve got a sharp eye fr, and I totally see where you're coming from. In my example, the async part is mostly happening upfront with
await response.json(), which, as you pointed out, isn't making full use of async iteration. Your version is spot on! By yielding eachfetchrequest, you're letting thefor awaitloop actually control the asynchronous flow, fetching each user in sequence. This approach really shows the power of async iterators, especially in scenarios with multiple network requests. Appreciate the suggestion—really helpful for making the concept clearer!Rare generator user! What do you think about generator vs. async arrow function ?
Good question! 😊 Generators give you more control since you can pause and resume functions, which is great for complex async flows. But async arrow functions are cleaner and easier for most use cases, especially when you just need to handle Promises simply and efficiently. So, for everyday async tasks, async functions are usually the way to go, but Generators shine when you need more flexibility. What’s your preference???
My preference is same. Befor async function are released I used a simple generator to solve complex problme, for example (really old one):
poker with generator
That’s awesome! Generators were such a game-changer back then. Checked out the Pen, really cool how you handled the complex async stuff. Even though it’s old, it’s great to see how effective those approaches were!!!👌
Thanks Shafayet for sharing!!
Thank you for sharing! I’d like to commend EchoAPI for truly elevating my JavaScript development experience with its powerful tools for efficient API management.
Thanks for the shoutout! EchoAPI sounds like it’s really boosting your JavaScript workflow. Great to hear it’s making a difference!!