JavaScript is a language that allows you to write asynchronous code, which means that you can perform multiple tasks at the same time without waiting for one to finish before starting another. For example, you can send a request to a server and continue with other operations while waiting for the response.
However, asynchronous code can also be challenging to write and understand, especially when you have to deal with nested callbacks, error handling, and complex logic. That’s where promises come in handy.
A promise is a JavaScript object that represents the eventual outcome of an asynchronous operation. It can either be fulfilled (resolved) with a value or rejected with a reason (error). A promise lets you write cleaner and more readable code by avoiding callback hell and providing a clear way to handle success and failure scenarios.
To create a promise, you use the Promise constructor, which takes a function as an argument. This function receives two parameters: resolve and reject, which are themselves functions that you can call to settle the promise.
For example, the following code creates a promise that resolves after 2 seconds with the message “Hello”:
To use a promise, you can call its then method, which takes two callbacks as arguments: one for success and one for failure. These callbacks are called when the promise is settled, either by resolving or rejecting.
For example, the following code uses the promise p from above and logs its value or error to the console:
You can also chain multiple then calls on a promise, creating a sequence of asynchronous operations. Each then call returns a new promise that is resolved with the return value of its callback. This way, you can pass data along the chain and handle errors at any point.
For example, the following code chains three then calls on a promise that resolves with a number. Each then call increments the number by one and returns it. The final then call logs the result to the console:
If any of the then callbacks throws an error or returns a rejected promise, the subsequent then callbacks are skipped and the error is passed to the next catch callback in the chain. The catch method is similar to then, but it only takes one callback for handling errors.
For example, the following code adds a catch callback to handle any errors that may occur in the previous then callbacks:
Finally, you can use the finally method to execute some code regardless of whether the promise is fulfilled or rejected. This is useful for performing some cleanup or final actions after an asynchronous operation.
For example, the following code adds a finally callback to log “Done” after the promise is settled:
In conclusion, promises are a powerful feature of JavaScript that allow you to write asynchronous code in a more elegant and manageable way. By using promises, you can avoid callback hell, handle errors gracefully, and chain multiple operations together. Promises are also compatible with other modern JavaScript features, such as async/await and generators. If you want to learn more about promises and how to use them effectively, you can check out some of the resources below:
I hope you enjoyed this article and learned something new. Happy coding!