Flash cards
Review the key moves
1/4
Core idea
What is the main idea behind Node.js Asynchronous Programming?
Lesson checks
Practice each idea before moving on
Short Mimo-style checks built from this lesson's code, terms, and sequence.
1Quick choice
Which statement best captures the main point of this lesson?
2Fill blank
Complete the missing token from the example code.
___ fs = require('fs');3Order
Put the learning moves in the order that makes the concept easiest to apply.
Even Better: Async/Await
Solution: Use Promises
Problem: Nested Callbacks (Callback Hell)
What is Asynchronous Programming?
In Node.js, asynchronous operations let your program do other work while waiting for tasks like file I/O or network requests to complete.
This non-blocking approach enables Node.js to handle thousands of concurrent connections efficiently.
Synchronous
- Blocks execution until complete
- Simple to understand
- Can cause delays
- Uses functions like readFileSync
Asynchronous
- Non-blocking execution
- Better performance
- More complex to handle
- Uses callbacks, promises, or async/await
Example: Synchronous File Read
const fs = require('fs');
console.log('1. Starting sync read...');
const data = fs.readFileSync('myfile.txt', 'utf8');
console.log('2. File contents:', data);
console.log('3. Done reading file');Output will be in order: 1 â 2 â 3 (blocks between each step)
Example: Asynchronous File Read
const fs = require('fs');
console.log('1. Starting async read...');
fs.readFile('myfile.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log('2. File contents:', data);
});
console.log('3. Done starting read operation');Output order: 1 â 3 â 2 (doesn't wait for file read to complete)
Problem: Nested Callbacks (Callback Hell)
getUser(userId, (err, user) => {
if (err) return handleError(err);
getOrders(user.id, (err, orders) => {
if (err) return handleError(err);
processOrders(orders, (err) => {
if (err) return handleError(err);
console.log('All done!');
});
});
});Solution: Use Promises
getUser(userId)
.then(user => getOrders(user.id))
.then(orders => processOrders(orders))
.then(() => console.log('All done!'))
.catch(handleError);Even Better: Async/Await
async function processUser(userId) {
try {
const user = await getUser(userId);
const orders = await getOrders(user.id);
await processOrders(orders);
console.log('All done!');
} catch (err) {
handleError(err);
}
}Promises
const fs = require('fs').promises;
console.log('1. Reading file...');
fs.readFile('myfile.txt', 'utf8')
.then(data => {
console.log('3. File content:', data);
})
.catch(err => console.error('Error:', err));
console.log('2. This runs before file is read!');Async/Await (Recommended)
async function readFiles() {
try {
console.log('1. Starting to read files...');
const data1 = await fs.readFile('file1.txt', 'utf8');
const data2 = await fs.readFile('file2.txt', 'utf8');
console.log('2. Files read successfully!');
return { data1, data2 };
} catch (error) {
console.error('Error reading files:', error);
}
}Do This
// Use async/await for better readability
async function getUserData(userId) {
try {
const user = await User.findById(userId);
const orders = await Order.find({ userId });
return { user, orders };
} catch (error) {
console.error('Failed to fetch user data:', error);
throw error; // Re-throw or handle appropriately
}
}Not This
// Nested callbacks are hard to read and maintain
User.findById(userId, (err, user) => {
if (err) return console.error(err);
Order.find({ userId }, (err, orders) => {
if (err) return console.error(err);
// Process orders...
});
});Key Takeaways
- â Use async/await for better readability
- â Always handle errors with try/catch
- â Run independent operations in parallel with Promise.all
- â Avoid mixing sync and async code patterns
- â Don't forget to await promises
// Run multiple async operations in parallel
async function fetchAllData() {
try {
const [users, products, orders] = await Promise.all([
User.find(),
Product.find(),
Order.find()
]);
return { users, products, orders };
} catch (error) {
console.error('Error fetching data:', error);
throw error;
}
}Why Use Asynchronous Code?
Asynchronous code lets Node.js handle many requests at once, without waiting for slow operations like file or database access.
This makes Node.js great for servers and real-time apps.
Asynchronous Programming in Node.js
- Node.js uses an event loop for non-blocking I/O
- Modern async code uses async/await with Promises
- Always handle errors in async operations
- Use Promise.all for parallel operations
- Avoid callback hell with proper async patterns