Topic 16724 min readStructured Tutorial

JavaScript Promise Interview Questions

Quick Answer

JavaScript Promises represent asynchronous operations and allow handling success or failure of those operations. Understanding how Promises work, their states, chaining, error handling, and common methods like then, catch, and finally is essential for JavaScript interviews.

Learning Objectives

Explain the purpose of Promise Interview Questions in a practical learning context.
Identify the main ideas, terms, and decisions involved in Promise Interview Questions.
Apply Promise Interview Questions in a simple real-world scenario or practice task.

Introduction

Promises are a fundamental part of modern JavaScript programming, especially for handling asynchronous operations.

In interviews, questions about Promises test your understanding of asynchronous control flow, error handling, and code readability.

Promises represent the eventual completion (or failure) of an asynchronous operation and its resulting value.

What is a Promise?

A Promise is an object representing the eventual completion or failure of an asynchronous operation.

It allows you to attach callbacks for success or failure, improving code readability compared to nested callbacks.

States: pending, fulfilled, rejected
Immutable once fulfilled or rejected
Supports chaining with then()

Common Promise Methods

Understanding Promise methods is crucial for interview success.

then(onFulfilled, onRejected): handles resolved or rejected states
catch(onRejected): handles only rejection
finally(onFinally): executes regardless of outcome

Promise Chaining and Error Handling

Promises can be chained to perform sequential asynchronous operations.

Errors in any step propagate down the chain until caught.

Return a value or Promise in then() to chain
Use catch() at the end to handle errors
finally() runs after then/catch regardless of outcome

Example of Promise Chaining

Here is an example demonstrating chaining and error handling.

Common Interview Questions on Promises

Interviewers often ask about Promise states, chaining, error handling, and differences with callbacks or async/await.

Explain Promise states and lifecycle
How does Promise chaining work?
Difference between then() and catch()
How to handle multiple Promises concurrently?
What is Promise.all and Promise.race?

Practical Example

This Promise resolves after 1 second and logs 'Success!'.

This example shows chaining, throwing an error, catching it, and finally running cleanup code.

Examples

Basic Promise Example

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

This Promise resolves after 1 second and logs 'Success!'.

Promise Chaining with Error Handling

new Promise((resolve, reject) => {
  resolve(1);
})
  .then(value => {
    console.log(value); // 1
    return value + 1;
  })
  .then(value => {
    console.log(value); // 2
    throw new Error('Something went wrong');
  })
  .catch(error => {
    console.error(error.message); // 'Something went wrong'
  })
  .finally(() => {
    console.log('Done');
  });

This example shows chaining, throwing an error, catching it, and finally running cleanup code.

Best Practices

Always handle Promise rejections with catch() to avoid unhandled errors.
Use finally() for cleanup tasks regardless of success or failure.
Prefer async/await syntax for readability but understand Promises under the hood.
Avoid nesting Promises; use chaining instead for cleaner code.
Use Promise.all() to run multiple Promises concurrently and wait for all to complete.

Common Mistakes

Not returning a Promise inside then(), breaking the chain.
Forgetting to handle rejected Promises, causing unhandled promise rejections.
Nesting Promises unnecessarily instead of chaining.
Misunderstanding that finally() does not receive the Promise result or error.
Using Promise.all() without handling individual Promise failures.

Hands-on Exercise

Create a Promise Chain

Write a Promise chain that fetches user data, then fetches posts for that user, and handles any errors.

Expected output: Logs user data, then posts, or error message if any step fails.

Hint: Use then() to chain and catch() to handle errors.

Use Promise.all

Create two Promises that resolve after different times and use Promise.all to log both results together.

Expected output: Logs an array with both results after both Promises resolve.

Hint: Use Promise.all with an array of Promises.

Interview Questions

What are the states of a JavaScript Promise?

Interview

A Promise has three states: pending (initial state), fulfilled (operation completed successfully), and rejected (operation failed). Once fulfilled or rejected, the state is immutable.

How does Promise chaining work?

Interview

Promise chaining works by returning a value or another Promise inside a then() callback. This allows sequential asynchronous operations where each step waits for the previous to complete.

What is the difference between then() and catch()?

Interview

then() handles both fulfillment and rejection if both callbacks are provided, while catch() is a shorthand for handling only rejection.

How do you handle multiple Promises concurrently?

Interview

You can use Promise.all() to run multiple Promises in parallel and wait for all to resolve, or Promise.race() to get the result of the first settled Promise.