Promises for cleaner async in Node.js - Step-by-Step Execution

Concept Flow - Promises for cleaner async

Start async task

↓

Create Promise

↓

Promise executor runs

↓

Async operation success?

↓

Resolve promise

↓

Then or Catch

↓

Handle result

↓

End

This flow shows how a Promise starts an async task, then resolves or rejects, and finally handles the result cleanly.

Execution Sample

Node.js

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

This code creates a Promise that waits 1 second then resolves with 'Done', then logs the result.

Execution Table

Step	Action	Promise State	Callback Triggered	Output
1	Create Promise object	Pending	No
2	Start setTimeout async task	Pending	No
3	Wait 1 second	Pending	No
4	setTimeout callback runs	Pending	No
5	Call resolve('Done')	Resolved	No
6	Promise state changes to Resolved	Resolved	Yes (then)
7	then callback runs with result='Done'	Resolved	Yes (then)	Console logs: Done
8	End of execution	Resolved	Yes (then)	Done printed

💡 Promise resolves after 1 second, then callback runs and logs 'Done', ending execution.

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 7	Final
promise	undefined	Promise { <pending> }	Promise { <fulfilled>: 'Done' }	Promise { <fulfilled>: 'Done' }	Promise { <fulfilled>: 'Done' }
result	undefined	undefined	undefined	'Done'	'Done'

Key Moments - 3 Insights

Why does the 'then' callback run only after the Promise resolves?

Because the Promise starts in 'Pending' state (see Step 1-5). The 'then' callback triggers only when the Promise state changes to 'Resolved' (Step 6), ensuring the async task finished.

What happens if we call reject instead of resolve?

If reject is called, the Promise state changes to 'Rejected' instead of 'Resolved'. Then the 'catch' callback runs instead of 'then'. This is not shown here but follows the same flow logic.

Why is the output empty before the Promise resolves?

Because the async task hasn't finished yet (Steps 1-5). The Promise is still 'Pending', so no callback runs and no output is produced until resolution.

Visual Quiz - 3 Questions

Look at the execution table, what is the Promise state at Step 3?

A Pending

B Resolved

C Rejected

D Settled

💡 Hint

Check the 'Promise State' column at Step 3 in the execution table.

At which step does the 'then' callback first run?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Callback Triggered' and 'Output' columns to see when the callback runs.

If the async task took 2 seconds instead of 1, how would the execution table change?

A Steps 3 and 4 would take longer before resolving

B Promise would resolve immediately at Step 2

C The 'then' callback would run before the Promise resolves

D The Promise would never resolve

💡 Hint

Consider the timing of the async task in Steps 3 and 4 before resolution.

Concept Snapshot

Promises help manage async tasks by representing future results.
Create a Promise with new Promise((resolve, reject) => {...}).
Use resolve(value) to mark success, reject(error) for failure.
Attach .then() for success handling, .catch() for errors.
Promises keep code clean and avoid nested callbacks.

Full Transcript

This lesson shows how Promises work in Node.js to handle asynchronous tasks cleanly. We start by creating a Promise that runs an async operation (setTimeout). Initially, the Promise is pending. After 1 second, the Promise resolves with a value 'Done'. When resolved, the .then() callback runs and logs the result. The execution table traces each step, showing the Promise state changes and when callbacks trigger. Key moments clarify why callbacks wait for resolution and what happens on rejection. The visual quiz tests understanding of Promise states and callback timing. The snapshot summarizes how to use Promises for cleaner async code.