What is Promise?

In JavaScript, a Promise is an object that represents the eventual completion or failure of an asynchronous operation. It is commonly used for handling asynchronous code and mitigating the complexities associated with callbacks and nested callbacks.

A Promise can exist in one of three states:

1. Pending:
   • The initial state when the Promise is created. The asynchronous operation is neither completed nor rejected at this point.
2. Fulfilled:
   • The state in which the asynchronous operation has completed successfully. The Promise returns a value, which can be accessed using the .then() method.
3. Rejected:
   • The state in which the asynchronous operation has encountered an error or failed. The Promise returns a reason for the rejection, and you can handle errors using the .catch() method.

Promises provide a cleaner and more structured way to work with asynchronous code compared to traditional callback functions. They allow developers to write code that resembles synchronous logic, making it easier to understand and maintain.

Here’s a simple example of using a Promise in JavaScript:

const fetchData = new Promise((resolve, reject) => {
  // Simulating an asynchronous operation
  setTimeout(() => {
    const success = true; // Set to false to simulate a rejection

    if (success) {
      resolve('Data successfully fetched');
    } else {
      reject('Error: Unable to fetch data');
    }
  }, 2000); // Simulating a delay of 2 seconds
});

// Using the Promise
fetchData
  .then((data) => {
    console.log(data); // Output: Data successfully fetched
  })
  .catch((error) => {
    console.error(error); // Output: Error: Unable to fetch data
  });

In this example, the fetchData Promise represents the result of an asynchronous operation. The .then() method is used to handle the fulfilled state, and the .catch() method is used to handle the rejected state. Promises simplify the management of asynchronous flows, making code more readable and maintainable.

Why Unhandled Promise Rejection happens?

An “Unhandled Promise Rejection” in JavaScript occurs when a Promise is rejected, and there is no corresponding .catch() or await handling to address that rejection. This situation leads to uncaught exceptions, which can adversely impact the stability of your application. The reasons for encountering unhandled promise rejections often include:

Missing Error Handling

Failure to include a .catch() or await handling for a rejected Promise allows the rejection to remain unhandled. It is crucial to implement appropriate error-handling mechanisms for Promises.

somePromise()
.then(result => {
// handle success
})
.catch(error => {
// handle error to prevent unhandled promise rejection
});

Unhandled Asynchronous Code

When dealing with asynchronous operations, it is essential to handle promise rejections for each asynchronous operation.

async function fetchData() {
  try {
    const result = await fetch('https://example.com/api');
    // handle result
  } catch (error) {
    // handle error to prevent unhandled promise rejection
  }
}

Timing Issues:

Unhandled promise rejections may occur if an error happens before setting up a .catch() or await, or if the rejection is triggered outside the context of the current execution stack.

Callback-Based APIs:

Some APIs follow callback-based patterns, and failing to handle errors properly in such APIs might result in unhandled promise rejections.

fs.readFile(‘example.txt’, ‘utf8’, (err, data) => {
if (err) {
// handle error to prevent unhandled promise rejection
} else {
// handle data
}
});

Event Emitters

When using libraries or modules based on event emitters, it is essential to appropriately handle error events.

emitter.on('error', (error) => {
  // handle error to prevent unhandled promise rejection
});

Promises Without Error Handling

Ensure that Promises are chained with .catch() or use try/catch with await to address potential rejections.

somePromise()
  .then(result => {
    // handle success
  })
  .then(anotherPromise)
  .catch(error => {
    // handle error to prevent unhandled promise rejection
  });