How to use promises?

A **Promise** in JavaScript is an object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. It allows you to write asynchronous code in a more manageable and readable way compared to traditional callback functions, helping to avoid "callback hell." ### What is a Promise? A Promise can be in one of three states: - **Pending:** The initial state, neither fulfilled nor rejected. - **Fulfilled:** The operation completed successfully, and the promise has a resulting value. - **Rejected:** The operation failed, and the promise has a reason for the failure (an error). ### How to Use Promises You create a promise using the `Promise` constructor, which takes a function with two parameters: `resolve` and `reject`. You call `resolve` when the asynchronous operation succeeds and `reject` when it fails. ```javascript const myPromise = new Promise((resolve, reject) => { // Simulate an async operation, like fetching data setTimeout(() => { const success = true; // change to false to simulate failure if (success) { resolve("Operation was successful!"); } else { reject("Operation failed."); } }, 1000); }); ``` To handle the result of a promise, you use the `.then()` and `.catch()` methods: ```javascript myPromise .then(result => { console.log(result); // Logs: Operation was successful! }) .catch(error => { console.error(error); // Logs error message if rejected }); ``` ### Chaining Promises Promises can be chained to perform a series of asynchronous operations in order: ```javascript fetch('https://api.example.com/data') // returns a promise .then(response => response.json()) // parse JSON from response .then(data => { console.log(data); return fetch('https://api.example.com/more-data'); }) .then(response => response.json()) .then(moreData => console.log(moreData)) .catch(error => console.error('Error:', error)); ``` ### Using Async/Await (Syntactic Sugar) Modern JavaScript also supports `async`/`await`, which makes working with promises look more like synchronous code: ```javascript async function fetchData() { try { const response = await fetch('https://api.example.com/data'); const data = await response.json(); console.log(data); } catch (error) { console.error('Error:', error); } } fetchData(); ``` ### Summary - Promises represent asynchronous operations. - Use `.then()` for success and `.catch()` for errors. - Chain promises for sequential async tasks. - Use `async`/`await` for cleaner, more readable async code. Promises are foundational for modern JavaScript asynchronous programming, making code easier to write, read, and maintain.

Promises are a feature in JavaScript used to handle asynchronous operations more cleanly and avoid the so-called "callback hell." A **promise** represents a value that may be available now, later, or never. It essentially acts as a placeholder for the result of an asynchronous task, such as fetching data from a server or reading a file. ### What is a Promise? A promise has three possible states: - **Pending:** The initial state, neither fulfilled nor rejected. - **Fulfilled:** The operation completed successfully, and the promise has a resulting value. - **Rejected:** The operation failed, and the promise has a reason for the failure (an error). ### How to Use Promises You create a new promise using the `Promise` constructor, which takes a function with two parameters: `resolve` and `reject`. You call `resolve(value)` when the async operation succeeds, or `reject(error)` if it fails. ```javascript const myPromise = new Promise((resolve, reject) => { // Simulate an async operation using setTimeout setTimeout(() => { const success = true; // Change to false to simulate failure if (success) { resolve("Operation succeeded!"); } else { reject("Operation failed."); } }, 1000); }); ``` To handle the result of the promise, use `.then()` for fulfilled cases and `.catch()` for rejected cases: ```javascript myPromise .then(result => { console.log(result); // Output: Operation succeeded! }) .catch(error => { console.error(error); // Output if rejected: Operation failed. }); ``` ### Using Async/Await Modern JavaScript also allows you to work with promises more naturally using `async`/`await` syntax, which makes asynchronous code look synchronous: ```javascript async function runAsyncTask() { try { const result = await myPromise; console.log(result); } catch (error) { console.error(error); } } runAsyncTask(); ``` ### Summary - Promises represent the eventual completion or failure of an async operation. - Use `new Promise()` to create a promise. - Use `.then()` and `.catch()` to handle success and failure. - Use `async`/`await` for cleaner and more readable asynchronous code. Promises help you write better asynchronous code by avoiding deeply nested callbacks and making error handling more straightforward.