**Course Title:** Modern JavaScript Programming: From Fundamentals to Full-Stack Development **Section Title:** Asynchronous JavaScript: Promises, Async/Await **Topic:** Working with Promises: `then`, `catch`, and chaining **Table of Contents** 1. Introduction to Promises 2. Understanding `then` and `catch` 3. Chaining Promises 4. Error Handling with Promises 5. Best Practices for Working with Promises 6. Conclusion **1. Introduction to Promises** In the previous lesson, we introduced the concept of asynchronous programming and callbacks. We also touched on promises, which provide a more manageable way of handling asynchronous operations. A promise represents a value that may not be available yet, but will be resolved at some point in the future. It's a more elegant and readable way of handling asynchronous code. **2. Understanding `then` and `catch`** When working with promises, you'll often use the `then` method to handle the resolved value and the `catch` method to handle any errors that may occur. * **`then` method:** The `then` method takes one or two arguments, both of which are optional. The first argument is a callback function that will be executed if the promise is resolved. The second argument is also a callback function that will be executed if the promise is rejected. However, the second argument can be omitted, and instead, you can use the `catch` method to handle errors. * **`catch` method:** The `catch` method takes one argument, which is a callback function that will be executed if the promise is rejected or if an error occurs. Here's an example of using `then` and `catch` methods: ```javascript // Create a promise that resolves after 2 seconds const promise = new Promise((resolve, reject) => { setTimeout(() => { resolve("Hello, world!"); }, 2000); }); // Use then and catch to handle the promise promise .then((value) => { console.log(value); // Output: Hello, world! }) .catch((error) => { console.error(error); }); ``` **3. Chaining Promises** One of the most powerful features of promises is the ability to chain them together. This allows you to execute multiple asynchronous operations in a specific order. When you return a value from a `then` method, it will be passed to the next `then` method in the chain. If an error occurs in the chain, it will be caught by the `catch` method. Here's an example of chaining promises: ```javascript // Create a promise that resolves after 2 seconds const promise = new Promise((resolve, reject) => { setTimeout(() => { resolve("Hello, world!"); }, 2000); }); // Chain promises to execute multiple asynchronous operations promise .then((value) => { // Return a new promise that resolves after 1 second return new Promise((resolve, reject) => { setTimeout(() => { resolve(`${value} Chained promise!`); }, 1000); }); }) .then((value) => { console.log(value); // Output: Hello, world! Chained promise! }) .catch((error) => { console.error(error); }); ``` **4. Error Handling with Promises** Error handling is crucial when working with promises. You can use the `catch` method to catch any errors that occur in the promise chain. It's a good practice to always include a `catch` method at the end of the chain to handle any unexpected errors. Here's an example of error handling with promises: ```javascript // Create a promise that rejects after 2 seconds const promise = new Promise((resolve, reject) => { setTimeout(() => { reject("Error occurred!"); }, 2000); }); // Use catch to handle the error promise .then((value) => { console.log(value); }) .catch((error) => { console.error(error); // Output: Error occurred! }); ``` **5. Best Practices for Working with Promises** Here are some best practices to keep in mind when working with promises: * Always include a `catch` method at the end of the promise chain to handle any unexpected errors. * Use the `then` method to handle resolved values and the `catch` method to handle errors. * Avoid using nested promises and instead use promise chaining to execute multiple asynchronous operations. * Keep your promise chains organized and readable by using clear function names and spacing. **Conclusion** In this lesson, we explored the basics of working with promises, including the `then` and `catch` methods, chaining promises, error handling, and best practices. Promises provide a more manageable way of handling asynchronous operations and are a fundamental concept in modern JavaScript development. If you have any questions, feel free to ask in the comments below. **External Resources** * [MDN Web Docs: Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) * [ECMAScript 2015 Language Specification: Promises](https://www.ecma-international.org/ecma-262/6.0/#sec-promise-objects) In the next lesson, we'll explore the async/await syntax for handling asynchronous operations.