Working with Promises

Asynchronous programming is an essential part of modern JavaScript development. It allows us to perform tasks in the background while keeping the main thread free for other operations. Promises are a powerful construct in JavaScript that enable us to work with async operations in a more manageable way.

A promise represents the eventual completion of an asynchronous operation and its resulting value. It has three states: pending, fulfilled, and rejected.

To create a promise, we use the Promise constructor and pass a function with two parameters: resolve and reject. Inside this function, we perform our asynchronous operation and call resolve when it succeeds or reject when it fails.

Here's an example of a simple promise that resolves after a timeout:

1const delay = (ms) => {
2  return new Promise((resolve) => {
3    setTimeout(() => {
4      resolve('Operation completed');
5    }, ms);
6  });
7};
8
9console.log('Start');
10delay(2000)
11  .then((result) => {
12    console.log(result);
13  });
14console.log('End');

In this example, the delay function returns a promise that resolves after a specified time delay. We can use the then method to handle the resolved value when the promise is fulfilled.

Promises offer powerful capabilities for working with async operations. We can chain promises, handle errors using catch, and perform parallel async operations using Promise.all or Promise.race.

Asynchronous programming and promises are foundational concepts in JavaScript. Understanding how to work with promises will greatly enhance your ability to perform async operations and handle their results effectively.

xxxxxxxxxx

const delay = (ms) => {

  return new Promise((resolve) => {

    setTimeout(() => {

      resolve('Operation completed');

    }, ms);

  });

};

​

console.log('Start');

delay(2000)

  .then((result) => {

    console.log(result);

  });

console.log('End');