Node.js Asynchronous Programming

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.

Sync vs Async: Key Differences

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

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)

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)

Avoiding 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);
}
}

Modern Async Patterns

1. 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!');

2. 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);
}
}

Best Practices

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

User.findById(userId, (err, user) => {
if (err) return console.error(err);
Order.find({ userId }, (err, orders) => {
if (err) return console.error(err);

});
});

Key Takeaways

✅ Use async/await for better readability
✅ Always handle errors with try/catch

Example: Parallel Execution

// 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?

This makes Node.js great for servers and real - time apps.

Summary

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

Avoid callback hell with proper async patterns