Async/Await

⏳ Async/Await

🔧 Async Functions

An async function always returns a promise:

Copyasync function greet() {
  return 'Hello!';
}

// This is equivalent to:
function greet() {
  return Promise.resolve('Hello!');
}

// Both return a promise
greet().then(msg => console.log(msg)); // Hello!

The value you return from an async function is automatically wrapped in a resolved promise.

⏸️ The await Keyword

await pauses execution until a promise settles. It can only be used inside an async function:

Copyasync function fetchUser(id) {
  // Pause here until promise resolves
  const user = await getUserFromDB(id);
  console.log('User:', user);
  return user;
}

// Call the async function
const result = fetchUser(1); // Returns a promise
result.then(user => console.log(user));

📊 Async/Await vs Promises

CopyfetchUser(1)
  .then(user => {
    console.log(user);
    return fetchOrders(user.id);
  })
  .then(orders => {
    console.log(orders);
  })
  .catch(error => {
    console.error(error);
  });

Copyasync function load() {
  try {
    const user = await fetchUser(1);
    console.log(user);
    const orders = await fetchOrders(user.id);
    console.log(orders);
  } catch (error) {
    console.error(error);
  }
}

load();

Async/await reads like synchronous code, making it much easier to follow.

🛡️ Error Handling with Try/Catch

Use try/catch to handle errors in async functions:

Copyasync function fetchUserData(id) {
  try {
    const user = await fetchUser(id);
    const orders = await fetchOrders(user.id);
    return { user, orders };
  } catch (error) {
    console.error('Failed to load data:', error.message);
    return null; // Return fallback value
  }
}

// Call it
await fetchUserData(1);

If any await expression rejects, execution jumps to catch.

⚡ Sequential vs Concurrent Execution

Sequential (Slow)

Copyasync function sequential() {
  const user = await fetchUser(1);      // 1000ms
  const posts = await fetchPosts(user.id); // 1000ms
  return { user, posts };                // Total: 2000ms
}

Concurrent (Fast)

Copyasync function concurrent() {
  // Start both promises, then await results
  const userPromise = fetchUser(1);     // Start here
  const postsPromise = fetchPosts(1);    // Start here

  // Wait for both
  const user = await userPromise;
  const posts = await postsPromise;
  return { user, posts };                 // Total: ~1000ms
}

// Or use Promise.all():
async function concurrent() {
  const [user, posts] = await Promise.all([
    fetchUser(1),
    fetchPosts(1)
  ]);
  return { user, posts };
}

🎯 Arrow Async Functions

Copyconst fetchAndLog = async (id) => {
  const user = await fetchUser(id);
  console.log(user);
};

// Usage
await fetchAndLog(1);

🚀 Top-Level Await (Modern Node.js)

In recent Node.js versions, you can use await at the top level of a module (no async function needed):

Copy// Old way: wrap in async function
async function main() {
  const data = await fetchData();
  console.log(data);
}
main();

// New way: use await directly
const data = await fetchData();
console.log(data);

💻 Coding Challenges

🎯 What's Next

Now that you can handle asynchronous code cleanly with async/await, we'll explore File System Operations — reading, writing, and managing files in Node.js using these async patterns.