JavaScript Notes

Top 30 JavaScript Promise Interview Questions & Answers 2026

Master JavaScript Promise interview questions with detailed answers. Covers Promise states, chaining, Promise.all/race/allSettled/any, async/await, error handling, and output questions.

Promises are the backbone of async JavaScript. Every interview from mid-level to senior level includes at least 3-5 Promise questions. This guide covers all of them with detailed answers.

Tips for Interview 💡

Always mention the 3 states: pending, fulfilled, rejected.
Know the difference between Promise.all, Promise.allSettled, Promise.race, Promise.any.
Explain that async/await is syntactic sugar over Promises.
Promise executor runs synchronously; .then callbacks run as microtasks.
Unhandled promise rejections cause process crashes in Node.js.

Q1: Create a Basic Promise

Example

Output

Executing...
Executing...
Resolved: Success!
Error: Network failed!

Q2: Promise Chaining

Example

Output

Step 1 done
Got: Step 1
Step 2 done
Got: Step 2
Final: Final

Q3: What is the Output? (Tricky)

Example

const p = new Promise((resolve, reject) => { console.log("A"); resolve("B"); reject("C"); // ignored — promise already settled console.log("D"); }); p.then(val => console.log("Then:", val)) .catch(err => console.log("Catch:", err)); console.log("E");

Output

A
D
E
Then: B

Key Points:

Executor runs synchronously → A, D print immediately.
Once resolve("B") is called, promise is settled → reject("C") is ignored.
"E" prints before .then (microtask).

Q4: Promise.all — All must succeed

Example

const p1 = Promise.resolve("User data"); const p2 = Promise.resolve("Product data"); const p3 = Promise.resolve("Order data"); Promise.all([p1, p2, p3]) .then(results => { console.log("All resolved:", results); }) .catch(err => console.log("One failed:", err));

Output

All resolved: ["User data", "Product data", "Order data"]

With failure:

Example

Promise.all([ Promise.resolve("A"), Promise.reject("Error!"), Promise.resolve("C") ]) .then(vals => console.log(vals)) .catch(err => console.log("Failed:", err));

Output

Failed: Error!

Q5: Promise.allSettled — Don't fail on rejection

Example

Promise.allSettled([ Promise.resolve("Success"), Promise.reject("Failure"), Promise.resolve("Another success") ]).then(results => { results.forEach(r => { if (r.status === "fulfilled") { console.log("✅", r.value); } else { console.log("❌", r.reason); } }); });

Output

✅ Success
❌ Failure
✅ Another success

Use case: When you want results from ALL promises, regardless of failure.

Q6: Promise.race — First to settle wins

Example

const slow = new Promise(resolve => setTimeout(() => resolve("slow"), 500)); const fast = new Promise(resolve => setTimeout(() => resolve("fast"), 100)); const error = new Promise((_, reject) => setTimeout(() => reject("error"), 200)); Promise.race([slow, fast, error]) .then(val => console.log("Winner:", val)) .catch(err => console.log("Error:", err));

Output

Winner: fast

Use case: Timeout patterns — race a fetch with a timeout promise.

Q7: Promise.any — First to FULFILL wins (ignores rejections)

Example

Promise.any([ Promise.reject("Error 1"), Promise.resolve("First success"), Promise.resolve("Second success") ]).then(val => console.log("First success:", val)) .catch(err => console.log("AggregateError:", err.errors));

Output

First success: First success

If ALL reject:

Example

Promise.any([ Promise.reject("E1"), Promise.reject("E2"), Promise.reject("E3") ]).catch(err => { console.log(err instanceof AggregateError); // true console.log(err.errors); });

Output

true
["E1", "E2", "E3"]

Q8: Comparison Table

Method	Behavior	Short-circuit
`Promise.all`	All must fulfill	On first rejection
`Promise.allSettled`	Wait for all to settle	Never
`Promise.race`	First to settle (fulfill or reject)	On first settlement
`Promise.any`	First to fulfill	On first fulfillment

Q9: Error Handling Chain

Example

Promise.resolve("start") .then(val => { console.log(val); throw new Error("Something broke"); }) .then(val => { console.log("This won't run"); }) .catch(err => { console.log("Caught:", err.message); return "recovered"; }) .then(val => { console.log("After recovery:", val); });

Output

start
Caught: Something broke
After recovery: recovered

Rule: Once an error is thrown in a chain, it skips all .then until the nearest .catch. After .catch returns, the chain continues normally.

Q10: .finally()

Example

Output

Data: data
Loading done: false
Final: data

Note: .finally() does NOT modify the resolved value — it passes through.

Q11: async/await Syntax

Example

async function getUser(id) { const user = await fetch(`/api/users/${id}`).then(r => r.json()); return user; } // Equivalent Promise version: function getUser(id) { return fetch(`/api/users/${id}`) .then(r => r.json()); }

Q12: async/await Error Handling

Example

async function fetchWithRetry(url, retries = 3) { for (let i = 0; i < retries; i++) { try { const response = await fetch(url); if (!response.ok) throw new Error(`HTTP ${response.status}`); return await response.json(); } catch (err) { console.log(`Attempt ${i + 1} failed: ${err.message}`); if (i === retries - 1) throw err; } } }

Q13: Sequential vs Parallel Promises

Example

// SEQUENTIAL (slow — waits for each) async function sequential() { console.time("sequential"); const a = await delay(100, "A"); const b = await delay(100, "B"); const c = await delay(100, "C"); console.timeEnd("sequential"); // ~300ms return [a, b, c]; } // PARALLEL (fast — all at once) async function parallel() { console.time("parallel"); const [a, b, c] = await Promise.all([ delay(100, "A"), delay(100, "B"), delay(100, "C") ]); console.timeEnd("parallel"); // ~100ms return [a, b, c]; } function delay(ms, val) { return new Promise(resolve => setTimeout(() => resolve(val), ms)); }

Output

sequential: ~300ms
parallel: ~100ms

Q14: Promisify Callback

Example

Output

file contents

Q15: Output — Promise in if/else

Example

let p; if (Math.random() > 0.5) { p = Promise.resolve("heads"); } else { p = Promise.resolve("tails"); } p.then(val => console.log("Result:", val)); console.log("After if/else");

Output

After if/else
Result: heads  (or tails — random)

Q16: Async Function Always Returns Promise

Example

async function getValue() { return 42; } const result = getValue(); console.log(result); // Promise {<fulfilled>: 42} result.then(val => console.log(val)); // 42

Output

Promise {<fulfilled>: 42}
42

Q17: await with non-Promise values

js example

async function test() {
  const a = await 42;       // Wraps in Promise.resolve(42)
  const b = await "hello";  // Wraps in Promise.resolve("hello")
  console.log(a, b);
}
test();

Output

42 hello

Q18: Chained async/await

js example

async function step1() { return "Step 1"; }
async function step2(val) { return val + " → Step 2"; }
async function step3(val) { return val + " → Step 3"; }

async function run() {
  const result = await step3(await step2(await step1()));
  console.log(result);
}

run();

Output

Step 1 → Step 2 → Step 3

Common Traps 🪤

Trap	Issue	Fix
Missing `await`	Promise returned, not value	Always `await` async calls
`await` in `.forEach`	Doesn't wait	Use `for...of` with `await`
Unhandled rejection	Silent crash in Node.js	Always `.catch()` or `try/catch`
`Promise.all` short-circuits	One rejection kills all	Use `Promise.allSettled` instead
Not returning in chain	Returns `undefined`	Always `return` from `.then`

The forEach Trap:

Example

// ❌ Wrong — doesn't await async function processAll(items) { items.forEach(async (item) => { await processItem(item); // IGNORED by forEach }); } // ✅ Correct — sequential async function processAll(items) { for (const item of items) { await processItem(item); } } // ✅ Correct — parallel async function processAll(items) { await Promise.all(items.map(item => processItem(item))); }

Interview Quick Reference

text example

Promise.resolve(val)     → Already fulfilled
Promise.reject(err)      → Already rejected
new Promise(fn)          → fn runs synchronously
.then(onFulfilled)       → Runs as microtask
.catch(onRejected)       → Same as .then(null, onRejected)
.finally(fn)             → Runs always, passes through value
async fn() { ... }       → Returns a Promise
await expr               → Pauses async fn, schedules resume as microtask

Practice Questions

Implement sleep(ms) that returns a Promise resolving after ms milliseconds.
Write timeout(promise, ms) that rejects if promise takes longer than ms.
Build promiseQueue(tasks, concurrency) — run N tasks at a time.
Implement a simple Promise class from scratch (constructor, then, catch).
Refactor callback hell to async/await with proper error handling.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Top 30 JavaScript Promise Interview Questions & Answers 2026.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this JavaScript Master Course topic.

Search Terms

javascript-complete-guide, javascript master course, javascript, complete, guide, interview, promise, questions

Continue learning this concept

InterviewTop 30 JavaScript Closure Interview Questions & Answers 2026Master closure interview questions with detailed answers, code examples, outputs, common traps, and tips. Covers IIFE, loop problem, data privacy, currying, memoization.InterviewTop 30 JavaScript Coding Interview Questions 2026 (With Solutions)Top 30 JavaScript coding interview questions with step-by-step solutions. Covers arrays, strings, objects, recursion, algorithms, and problem-solving patterns for 2026 interviews.InterviewTop 25 JavaScript Event Loop Interview Questions & Answers 2026Master JavaScript event loop interview questions with call stack, microtasks, macrotasks, Promise order, async/await execution, and real output prediction examples.Interview50 Tricky JavaScript Output Questions 2026 (With Answers)50 tricky JavaScript output questions with detailed answers. Covers type coercion, hoisting, closures, event loop, promises, prototype, scope — ace your 2026 JS interview.InterviewTop 50 JavaScript Interview Questions & Answers 2026Complete JavaScript interview guide 2026. Covers 50 most asked questions on closures, hoisting, promises, prototypes, async/await, event loop, DOM, and ES6+ features.Interview PreparationJavaScript Interview — Behavioral Questions and Soft Skills Guide 2026Master behavioral interview questions for JavaScript developer roles. Learn how to structure answers about teamwork, debugging challenges, code reviews, and technical decision-making using the STAR method.

PreviousTop 50 JavaScript Interview Questions & Answers 2026 Next50 Tricky JavaScript Output Questions 2026 (With Answers)