Promises are a way to handle asynchronous operations. They are objects that represent the eventual completion (or failure) of an asynchronous operation and allow you to handle the result of that operation.
A promise can be in one of three states:
Pending, fulfilled, or rejected. When a promise is pending, it means that the asynchronous operation is still in progress.
When the operation is completed successfully, the promise is fulfilled and the result of the operation is available.
If an error occurs during the operation, the promise is rejected and an error message or object is provided.
Promises provide a clean and structured way to work with asynchronous code. They allow you to attach callbacks (also known as “then” handlers) to the promise, which will be executed when the promise is fulfilled or rejected.
Here’s an example of how promises can be used in JavaScript:
// Creating a promise
const myPromise = new Promise((resolve, reject) => {
// Simulating an asynchronous operation
setTimeout(() => {
const randomNumber = Math.random();
if (randomNumber < 0.5) {
resolve(randomNumber);
} else {
reject(new Error('Promise rejected'));
}
}, 1000);
});
// Handling the promise
myPromise
.then(result => {
console.log('Promise fulfilled:', result);
})
.catch(error => {
console.error('Promise rejected:', error);
});
In this example, a promise is created with a function that represents an asynchronous operation. After a delay of 1 second, the function generates a random number and resolves the promise if the number is less than 0.5, or rejects the promise otherwise. The promise is then handled using the then and catch methods.
If the promise is fulfilled, the then callback is executed and the result is logged to the console.
If the promise is rejected, the catch callback is executed and the error is logged.
Promises can also be chained together using the then method, allowing you to perform a series of asynchronous operations sequentially. This is known as promise chaining.
