Swiftorial Logo
Home
Swift Lessons
Matchups
CodeSnaps
Tutorials
Career
Resources

Using Promises in Node.js

1. Introduction

Promises are an essential feature of modern JavaScript, allowing for easier management of asynchronous operations. They represent a value that may be available now, or in the future, or never.

2. What are Promises?

A Promise is an object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value.

Key Takeaway: Promises help in avoiding callback hell and provide a cleaner way to handle asynchronous code.

States of a Promise:

  • Pending: The initial state, neither fulfilled nor rejected.
  • Fulfilled: The operation completed successfully.
  • Rejected: The operation failed.

3. Creating Promises

To create a Promise, you use the Promise constructor, which takes a function that has two arguments: resolve and reject.


const myPromise = new Promise((resolve, reject) => {
    // Simulating asynchronous operation
    const success = true; // Change to false to simulate failure
    if (success) {
        resolve("Operation completed successfully!");
    } else {
        reject("Operation failed.");
    }
});
            

4. Using Promises

Once a Promise is created, you can handle its result using the `.then()` and `.catch()` methods.


myPromise
    .then(result => {
        console.log(result); // Output: Operation completed successfully!
    })
    .catch(error => {
        console.error(error); // Output: Operation failed.
    });
            

5. Error Handling

Errors can be handled gracefully using the `.catch()` method. This is crucial for maintaining robust applications.

Tip: Always handle rejections to avoid unhandled promise rejections.

6. Best Practices

  • Always return promises from functions that perform asynchronous operations.
  • Chain promises for better readability and flow.
  • Utilize async/await syntax for cleaner asynchronous code.

7. FAQ

What is the difference between a Promise and a callback?

Promises provide a more powerful and flexible mechanism for handling asynchronous operations than callbacks.

Can a Promise be resolved multiple times?

No, a Promise can only be resolved or rejected once. Subsequent calls to resolve or reject will be ignored.

What is Promise.all?

Promise.all takes an array of Promises and returns a single Promise that resolves when all of the promises in the array have resolved.