Promises for cleaner async in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Promise chain?

Consider the following Node.js code using Promises. What will be logged to the console?

Node.js

Promise.resolve(5)
  .then(x => x * 2)
  .then(x => { throw new Error('Fail'); })
  .catch(() => 10)
  .then(x => x + 1)
  .then(console.log);

A 11

B Error: Fail

C 6

D undefined

💡 Hint

Remember that catch returns a resolved Promise with the value it returns.

The chain starts with 5, doubles to 10, then throws an error. The catch handles the error and returns 10. Then 1 is added, resulting in 11, which is logged.

❓ component_behavior

intermediate

Which option correctly returns a Promise that resolves after 1 second?

You want to create a function that returns a Promise resolving with 'done' after 1 second. Which code does this correctly?

A function wait() { return Promise.resolve(setTimeout(() => 'done', 1000)); }

B function wait() { setTimeout(() => Promise.resolve('done'), 1000); }

C function wait() { return new Promise(resolve => setTimeout(() => resolve('done'), 1000)); }

D function wait() { return new Promise(resolve => resolve(setTimeout(() => 'done', 1000))); }

💡 Hint

Remember that setTimeout returns a timer ID, not a Promise.

Option C correctly creates a Promise and resolves it after 1 second using setTimeout. Other options either don't return a Promise or resolve immediately.

🔧 Debug

advanced

Why does this Promise chain never log anything?

Look at this code snippet. Why does it never log 'Finished'?

Node.js

Promise.resolve()
  .then(() => { throw 'Error happened'; })
  .then(() => console.log('Finished'));

A Because the Promise never resolves.

B Because console.log is inside a then that never runs due to syntax error.

C Because the Promise chain is missing a return statement.

D Because the error is thrown but not caught, so the last then is skipped.

💡 Hint

Think about what happens when a Promise rejects and no catch is present.

The thrown error causes the Promise to reject. Without a catch, the next then is skipped, so 'Finished' is never logged.

📝 Syntax

advanced

Which option correctly chains Promises to fetch data and process it?

Given fetchData() returns a Promise resolving to data, which code correctly fetches and logs the processed data?

Node.js

function process(data) { return data.length; }

A fetchData().then(data => process(data)).then(result => console.log(result));

B fetchData().then(process).then(console.log);

C fetchData().then(process()).then(console.log);

D fetchData().then(data => { process(data); }).then(console.log);

💡 Hint

Remember to pass functions, not call them immediately in then.

Options A and B correctly pass functions to then. Option C calls process immediately, D does not return from then.

🧠 Conceptual

expert

What is the behavior of Promise.all with mixed resolved and rejected Promises?

Given these Promises: p1 resolves, p2 rejects, p3 resolves. What does Promise.all([p1, p2, p3]) do?

A It resolves with an array of all results including the rejection reason.

B It immediately rejects with p2's rejection reason, ignoring p1 and p3 results.

C It waits for all Promises and then resolves with only the successful results.

D It resolves with the first resolved Promise's value.

💡 Hint

Promise.all rejects as soon as any Promise rejects.

Promise.all rejects immediately when any Promise rejects, with that rejection reason.

Practice

1. What is the main purpose of using Promises in Node.js?

easy

A. To store data permanently on disk

B. To make the program run faster by using multiple CPUs

C. To write synchronous code only

D. To handle asynchronous tasks without freezing the program

Solution

1. Step 1: Understand asynchronous tasks

   Asynchronous tasks take time and can block the program if not handled properly.

2. Step 2: Role of Promises

   Promises allow handling these tasks without freezing the program by running code after the task finishes.

3. Final Answer:

   To handle asynchronous tasks without freezing the program -> Option D

4. Quick Check:

   Promises manage async tasks = A [OK]

Hint: Promises help avoid freezing during slow tasks [OK]

Common Mistakes:

• Thinking Promises speed up code execution
• Confusing Promises with synchronous code
• Believing Promises store data permanently

2. Which of the following is the correct way to create a Promise in Node.js?

easy

A. const p = Promise(() => { resolve(); });

B. const p = new Promise((resolve, reject) => { /* code */ });

C. const p = new Promise(resolve, reject);

D. const p = Promise.new((resolve, reject) => { });

Solution

1. Step 1: Check Promise constructor syntax

   The Promise constructor requires a function with two parameters: resolve and reject.

2. Step 2: Validate each option

   const p = new Promise((resolve, reject) => { /* code */ }); correctly uses new Promise with a function taking resolve and reject.

3. Final Answer:

   const p = new Promise((resolve, reject) => { /* code */ }); -> Option B

4. Quick Check:

   Correct Promise syntax = B [OK]

Hint: Use 'new Promise' with (resolve, reject) function [OK]

Common Mistakes:

• Omitting 'new' keyword
• Passing resolve and reject outside a function
• Using incorrect Promise constructor syntax

3. What will the following code output?

const promise = new Promise((resolve) => {
  setTimeout(() => resolve('Done'), 100);
});
promise.then(result => console.log(result));
console.log('Start');

medium

A. Start only

B. Done\nStart

C. Start\nDone

D. Done only

Solution

1. Step 1: Understand asynchronous setTimeout

   The setTimeout delays resolve by 100ms, so 'Done' logs after delay.

2. Step 2: Order of console logs

   'Start' logs immediately, then after 100ms 'Done' logs from the promise.

3. Final Answer:

   Start\nDone -> Option C

4. Quick Check:

   Async delay means 'Start' first, then 'Done' [OK]

Hint: Immediate logs appear before delayed Promise results [OK]

Common Mistakes:

• Assuming Promise resolves immediately
• Expecting 'Done' before 'Start'
• Ignoring asynchronous behavior of setTimeout

4. Identify the error in this Promise code:

const p = new Promise((resolve, reject) => {
  resolve('Success');
  reject('Error');
});
p.then(result => console.log(result))
 .catch(error => console.log(error));

medium

A. Calling reject after resolve has no effect

B. Missing catch block for errors

C. Promise constructor missing 'new' keyword

D. resolve and reject parameters are reversed

Solution

1. Step 1: Understand Promise state changes

   Once a Promise is resolved or rejected, further calls to resolve or reject are ignored.

2. Step 2: Analyze code behavior

   The code calls resolve first, so reject after that does nothing.

3. Final Answer:

   Calling reject after resolve has no effect -> Option A

4. Quick Check:

   Promise settles once; later calls ignored [OK]

Hint: Promise settles once; ignore calls after resolve/reject [OK]

Common Mistakes:

• Expecting both resolve and reject to run
• Forgetting Promise settles only once
• Confusing order of resolve and reject calls

5. You want to run two async tasks one after another using Promises. Which code correctly chains them to run sequentially?

hard

A. task1().then(() => task2()).then(result => console.log(result));

B. Promise.all([task1(), task2()]).then(results => console.log(results));

C. task1(); task2(); console.log('Done');

D. task1().catch(() => task2()).then(result => console.log(result));

Solution

1. Step 1: Understand sequential chaining

   To run tasks one after another, call the second in the first's .then() callback.

2. Step 2: Analyze options

   task1().then(() => task2()).then(result => console.log(result)); chains task2 after task1 completes, ensuring order.

3. Final Answer:

   task1().then(() => task2()).then(result => console.log(result)); -> Option A

4. Quick Check:

   Chain with .then() for sequential async tasks [OK]

Hint: Use .then() chaining to run tasks one after another [OK]

Common Mistakes:

• Using Promise.all for sequential tasks (runs parallel)
• Calling tasks without chaining (runs parallel)
• Misusing catch to run second task