Node.js Promises

A Promise in JavaScript represents the eventual completion or failure of an asynchronous operation. Promises help us organize asynchronous code without deeply nesting callbacks.

1. What Is a Promise?

A Promise is an object used to handle the result of an asynchronous operation. It can be fulfilled with a value or rejected with a reason, such as an error.

2. Create Your First Promise

We create a Promise using the new Promise() constructor. Its executor function receives two functions: resolve() and reject().

const myPromise = new Promise((resolve, reject) => {
    resolve('Operation successful!');
});

myPromise.then((result) => {
    console.log(result);
});

Operation successful!

3. Using resolve() and reject()

Use resolve() to fulfill a Promise and reject() to reject it.

const promise = new Promise((resolve, reject) => {
    const marks = 80;

    if (marks >= 40) {
        resolve('Student passed!');
    } else {
        reject(new Error('Student failed.'));
    }
});

promise
    .then((message) => {
        console.log(message);
    })
    .catch((error) => {
        console.log(error.message);
    });

Student passed!

4. Using then()

The .then() method registers handlers for a fulfilled Promise. It can also accept a rejection handler as its second argument, although .catch() is often clearer for error handling.

const promise = Promise.resolve(100);

promise.then((value) => {
    console.log('Value:', value);
});

Value: 100

5. Using catch()

The .catch() method handles a rejected Promise. It is commonly used to handle errors from a Promise chain.

const promise = new Promise((resolve, reject) => {
    reject(new Error('Something went wrong!'));
});

promise
    .then((result) => {
        console.log(result);
    })
    .catch((error) => {
        console.log('Error:', error.message);
    });

Error: Something went wrong!

6. Using finally()

The .finally() method runs when a Promise settles, whether it fulfills or rejects. It is useful for cleanup tasks.

Promise.resolve('Data loaded')
    .then((result) => {
        console.log(result);
    })
    .catch((error) => {
        console.log(error.message);
    })
    .finally(() => {
        console.log('Operation finished.');
    });

Data loaded
Operation finished.

7. Promise Chaining

Promise chaining allows us to perform multiple operations in sequence. Each .then() can return a value or another Promise for the next step.

Promise.resolve(10)
    .then((number) => {
        console.log('Original:', number);
        return number + 5;
    })
    .then((number) => {
        console.log('After addition:', number);
        return number * 2;
    })
    .then((number) => {
        console.log('Final result:', number);
    })
    .catch((error) => {
        console.log('Error:', error.message);
    });

Original: 10
After addition: 15
Final result: 30

8. Promise with setTimeout()

We can create a Promise that fulfills after a delay. This technique is useful for learning asynchronous execution.

function getMessage() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve('Message received!');
        }, 2000);
    });
}

console.log('Start');

getMessage().then((message) => {
    console.log(message);
});

console.log('End');

Start
End
Message received!

9. Promise.resolve() and Promise.reject()

These static methods create fulfilled or rejected Promises. They are useful when a Promise is needed without writing the constructor directly.

Promise.resolve('Success')
    .then((message) => {
        console.log(message);
    });

Promise.reject(new Error('Failure'))
    .catch((error) => {
        console.log(error.message);
    });

Success
Failure

10. Promise.all()

Promise.all() accepts an iterable of Promises and fulfills when all of them fulfill. If any input Promise rejects, the returned Promise rejects with that reason.

const p1 = Promise.resolve('Student data');
const p2 = Promise.resolve('Course data');
const p3 = Promise.resolve('Fee data');

Promise.all([p1, p2, p3])
    .then((results) => {
        console.log(results);
    })
    .catch((error) => {
        console.log('Error:', error.message);
    });

[
  'Student data',
  'Course data',
  'Fee data'
]

11. Promise.allSettled()

Promise.allSettled() waits for every input Promise to settle. Its result describes whether each Promise fulfilled or rejected.

const p1 = Promise.resolve('Success');
const p2 = Promise.reject(new Error('Failed'));

Promise.allSettled([p1, p2]).then((results) => {
    results.forEach((result) => {
        console.log(result.status);
    });
});

fulfilled
rejected

12. Important Promise Methods

13. Practical Example: Student Result

This example checks a student's marks using a Promise and displays the result.

function checkResult(marks) {
    return new Promise((resolve, reject) => {
        if (marks >= 40) {
            resolve('Congratulations! You passed.');
        } else {
            reject(new Error('Sorry! You failed.'));
        }
    });
}

checkResult(75)
    .then((message) => {
        console.log(message);
    })
    .catch((error) => {
        console.log(error.message);
    })
    .finally(() => {
        console.log('Result checking completed.');
    });

Congratulations! You passed.
Result checking completed.

📝 Practical Assignment