Discover Promises in Node.js

A Promise is a special object in JavaScript that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. Essentially, a Promise is a placeholder for a value that is not yet available but will be in the future.

Think of a Promise like ordering a pizza: you don't get it right away, but the delivery person promises to bring it to you later. You don't know exactly when, but you know the outcome will either be "pizza delivered" or "something went wrong."

Promise States

A Promise can be in one of three states:

  • Pending: The initial state, where the asynchronous operation is still running.
  • Fulfilled: The operation completed successfully, and the Promise is now resolved with a value.
  • Rejected: The operation failed, and the Promise is settled with a reason (usually an error).

When you order the pizza, you're in the pending state, hungry and hopeful. If the pizza arrives hot and cheesy, you've entered the fulfilled state. But if the restaurant calls to say they've dropped your pizza on floor, you're in the rejected state.

Regardless of whether your dinner ends in joy or disappointment, once there's a final outcome, the Promise is considered settled.

Basic Syntax of a Promise

One of the most common ways to create a Promise is using the new Promise() constructor. The constructor takes a function with two parameters: resolve and reject. These functions are used to transition the Promise from the pending state to either fulfilled or rejected.

If an error is thrown inside the executor function, the Promise will be rejected with that error. The return value of the executor function is ignored: only resolve or reject should be used to settle the Promise.

const const myPromise: Promise<any>myPromise = new 
var Promise: PromiseConstructor
new <any>(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void) => Promise<any>
Creates a new Promise.
@paramexecutor A callback used to initialize the promise. This callback is passed two arguments:
a resolve callback used to resolve the promise with a value or the result of another promise,
and a reject callback used to reject the promise with a provided reason or error.
Promise((resolve: (value: any) => voidresolve, reject: (reason?: any) => voidreject) => {
  const const success: truesuccess = true;

  if (const success: truesuccess) {
    resolve: (value: any) => voidresolve('Operation was successful!');
  } else {
    reject: (reason?: any) => voidreject('Something went wrong.');
  }
});
JavaScript

In the above example:

  • If the success condition is true, the Promise is fulfilled and the value 'Operation was successful!' is passed to the resolve function.
  • If the success condition is false, the Promise is rejected and the error 'Something went wrong.' is passed to the reject function.

Handling Promises with .then(), .catch(), and .finally()

Once a Promise is created, you can handle the outcome by using the .then(), .catch(), and .finally() methods.

  • .then() is used to handle a fulfilled Promise and access its result.
  • .catch() is used to handle a rejected Promise and catch any errors that may occur.
  • .finally() is used to handle a settled Promise, regardless of whether the Promise resolved or rejected.
const const myPromise: Promise<any>myPromise = new 
var Promise: PromiseConstructor
new <any>(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void) => Promise<any>
Creates a new Promise.
@paramexecutor A callback used to initialize the promise. This callback is passed two arguments:
a resolve callback used to resolve the promise with a value or the result of another promise,
and a reject callback used to reject the promise with a provided reason or error.
Promise((resolve: (value: any) => voidresolve, reject: (reason?: any) => voidreject) => {
  const const success: truesuccess = true;

  if (const success: truesuccess) {
    resolve: (value: any) => voidresolve('Operation was successful!');
  } else {
    reject: (reason?: any) => voidreject('Something went wrong.');
  }
});

const myPromise: Promise<any>myPromise
  .Promise<any>.then<void, never>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(result: anyresult => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult); // This will run if the Promise is fulfilled
  })
  .Promise<void>.catch<void>(onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
Attaches a callback for only the rejection of the Promise.
@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of the callback.
catch(error: anyerror => {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error(error: anyerror); // This will run if the Promise is rejected
  })
  .Promise<void>.finally(onfinally?: (() => void) | null | undefined): Promise<void>
Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
resolved value cannot be modified from the callback.
@paramonfinally The callback to execute when the Promise is settled (fulfilled or rejected).@returnsA Promise for the completion of the callback.
finally(() => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('The promise has completed'); // This will run when the Promise is settled
  });
JavaScript

Chaining Promises

One of the great features of Promises is that they allow you to chain multiple asynchronous operations together. When you chain Promises, each .then() block waits for the previous one to complete before it runs.

const { setTimeout: import delaydelay } = require: anyrequire('node:timers/promises');

const const promise: anypromise = import delaydelay(1000).then(() => 'First task completed');

const promise: anypromise
  .then(result: anyresult => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult); // 'First task completed'
    return import delaydelay(1000).then(() => 'Second task completed'); // Return a second Promise
  })
  .then(result: anyresult => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult); // 'Second task completed'
  })
  .catch(error: anyerror => {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error(error: anyerror); // If any Promise is rejected, catch the error
  });
JavaScript

Using Async/Await with Promises

One of the best ways to work with Promises in modern JavaScript is using async/await. This allows you to write asynchronous code that looks synchronous, making it much easier to read and maintain.

  • async is used to define a function that returns a Promise.
  • await is used inside an async function to pause execution until a Promise settles.
async function function performTasks(): Promise<void>performTasks() {
  try {
    const const result1: anyresult1 = await promise1;
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(const result1: anyresult1); // 'First task completed'

    const const result2: anyresult2 = await promise2;
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(const result2: anyresult2); // 'Second task completed'
  } catch (function (local var) error: unknownerror) {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error(function (local var) error: unknownerror); // Catches any rejection or error
  }
}

function performTasks(): Promise<void>performTasks();
JavaScript

In the performTasks function, the await keyword ensures that each Promise is settled before moving on to the next statement. This leads to a more linear and readable flow of asynchronous code.

Essentially, the code above will execute the same as if the user wrote:

promise1
  .then(function (result1: anyresult1) {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result1: anyresult1);
    return promise2;
  })
  .then(function (result2: anyresult2) {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result2: anyresult2);
  })
  .catch(function (error: anyerror) {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(error: anyerror);
  });
JavaScript

Top-Level Await

When using ECMAScript Modules, the module itself is treated as a top-level scope that supports asynchronous operations natively. This means that you can use await at the top level without needing an async function.

import { setTimeout as import delaydelay } from 'node:timers/promises';

await import delaydelay(1000);
JavaScript

Async/await can be much more intricate than the simple examples provided. James Snell, a member of the Node.js Technical Steering Committee, has an in-depth presentation that explores the complexities of Promises and async/await.

Promise-based Node.js APIs

Node.js provides Promise-based versions of many of its core APIs, especially in cases where asynchronous operations were traditionally handled with callbacks. This makes it easier to work with Node.js APIs and Promises, and reduces the risk of "callback hell."

For example, the fs (file system) module has a Promise-based API under fs.promises:

const import fsfs = require: anyrequire('node:fs').promises;
// Or, you can import the promisified version directly:
// const fs = require('node:fs/promises');

async function function readFile(): Promise<void>readFile() {
  try {
    const const data: anydata = await import fsfs.readFile('example.txt', 'utf8');
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(const data: anydata);
  } catch (function (local var) err: unknownerr) {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error('Error reading file:', function (local var) err: unknownerr);
  }
}

function readFile(): Promise<void>readFile();
JavaScript

In this example, fs.readFile() returns a Promise, which we handle using async/await syntax to read the contents of a file asynchronously.

Advanced Promise Methods

JavaScript's Promise global provides several powerful methods that help manage multiple asynchronous tasks more effectively:

Promise.all()

This method accepts an array of Promises and returns a new Promise that resolves once all the Promises are fulfilled. If any Promise is rejected, Promise.all() will immediately reject. However, even if rejection occurs, the Promises continue to execute. When handling a large number of Promises, especially in batch processing, using this function can strain the system's memory.

const { setTimeout: import delaydelay } = require: anyrequire('node:timers/promises');

const const fetchData1: anyfetchData1 = import delaydelay(1000).then(() => 'Data from API 1');
const const fetchData2: anyfetchData2 = import delaydelay(2000).then(() => 'Data from API 2');

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.all<[any, any]>(values: [any, any]): Promise<any> (+1 overload)
Creates a Promise that is resolved with an array of results when all of the provided Promises
resolve, or rejected when any Promise is rejected.
@paramvalues An array of Promises.@returnsA new Promise.
all([const fetchData1: anyfetchData1, const fetchData2: anyfetchData2])
  .Promise<any>.then<void, never>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(results: anyresults => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(results: anyresults); // ['Data from API 1', 'Data from API 2']
  })
  .Promise<void>.catch<void>(onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
Attaches a callback for only the rejection of the Promise.
@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of the callback.
catch(error: anyerror => {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error('Error:', error: anyerror);
  });
JavaScript

Promise.allSettled()

This method waits for all promises to either resolve or reject and returns an array of objects that describe the outcome of each Promise.

const const promise1: Promise<string>promise1 = var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)
Creates a new resolved promise for the provided value.
@paramvalue A promise.@returnsA promise whose internal state matches the provided promise.
resolve('Success');
const const promise2: Promise<never>promise2 = var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.reject<never>(reason?: any): Promise<never>
Creates a new rejected promise for the provided reason.
@paramreason The reason the promise was rejected.@returnsA new rejected Promise.
reject('Failed');

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.allSettled<[Promise<string>, Promise<never>]>(values: [Promise<string>, Promise<never>]): Promise<[PromiseSettledResult<string>, PromiseSettledResult<...>]> (+1 overload)
Creates a Promise that is resolved with an array of results when all
of the provided Promises resolve or reject.
@paramvalues An array of Promises.@returnsA new Promise.
allSettled([const promise1: Promise<string>promise1, const promise2: Promise<never>promise2]).Promise<[PromiseSettledResult<string>, PromiseSettledResult<never>]>.then<void, never>(onfulfilled?: ((value: [PromiseSettledResult<string>, PromiseSettledResult<never>]) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<...>) | ... 1 more ... | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(results: [PromiseSettledResult<string>, PromiseSettledResult<never>]results => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(results: [PromiseSettledResult<string>, PromiseSettledResult<never>]results);
  // [ { status: 'fulfilled', value: 'Success' }, { status: 'rejected', reason: 'Failed' } ]
});
JavaScript

Unlike Promise.all(), Promise.allSettled() does not short-circuit on failure. It waits for all promises to settle, even if some reject. This provides better error handling for batch operations, where you may want to know the status of all tasks, regardless of failure.

Promise.race()

This method resolves or rejects as soon as the first Promise settles, whether it resolves or rejects. Regardless of which promise settles first, all promises are fully executed.

const { setTimeout: import delaydelay } = require: anyrequire('node:timers/promises');

const const task1: anytask1 = import delaydelay(2000).then(() => 'Task 1 done');
const const task2: anytask2 = import delaydelay(1000).then(() => 'Task 2 done');

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.race<[any, any]>(values: [any, any]): Promise<any> (+1 overload)
Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
or rejected.
@paramvalues An array of Promises.@returnsA new Promise.
race([const task1: anytask1, const task2: anytask2]).Promise<any>.then<void, never>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(result: anyresult => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult); // 'Task 2 done' (since task2 finishes first)
});
JavaScript

Promise.any()

This method resolves as soon as one of the Promises resolves. If all promises are rejected, it will reject with an AggregateError.

const { setTimeout: import delaydelay } = require: anyrequire('node:timers/promises');

const const api1: anyapi1 = import delaydelay(2000).then(() => 'API 1 success');
const const api2: anyapi2 = import delaydelay(1000).then(() => 'API 2 success');
const const api3: anyapi3 = import delaydelay(1500).then(() => 'API 3 success');

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.any<[any, any, any]>(values: [any, any, any]): Promise<any> (+1 overload)
The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
@paramvalues An array or iterable of Promises.@returnsA new Promise.
any([const api1: anyapi1, const api2: anyapi2, const api3: anyapi3])
  .Promise<any>.then<void, never>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(result: anyresult => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult); // 'API 2 success' (since it resolves first)
  })
  .Promise<void>.catch<void>(onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
Attaches a callback for only the rejection of the Promise.
@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of the callback.
catch(error: anyerror => {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error('All promises rejected:', error: anyerror);
  });
JavaScript

Promise.reject() and Promise.resolve()

These methods create a rejected or resolved Promise directly.

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)
Creates a new resolved promise for the provided value.
@paramvalue A promise.@returnsA promise whose internal state matches the provided promise.
resolve('Resolved immediately').Promise<string>.then<void, never>(onfulfilled?: ((value: string) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(result: stringresult => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: stringresult); // 'Resolved immediately'
});
JavaScript

Promise.try()

Promise.try() is a method that executes a given function, whether it's synchronous or asynchronous, and wraps the result in a promise. If the function throws an error or returns a rejected promise, Promise.try() will return a rejected promise. If the function completes successfully, the returned promise will be fulfilled with its value.

This can be particularly useful for starting promise chains in a consistent way, especially when working with code that might throw errors synchronously.

function function mightThrow(): stringmightThrow() {
  if (var Math: Math
An intrinsic object that provides basic mathematics functionality and constants.
Math.Math.random(): number
Returns a pseudorandom number between 0 and 1.
random() > 0.5) {
    throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Oops, something went wrong!');
  }
  return 'Success!';
}

var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.try<string, []>(callbackFn: () => string | PromiseLike<string>): Promise<string>
Takes a callback of any kind (returns or throws, synchronously or asynchronously) and wraps its result
in a Promise.
@paramcallbackFn A function that is called synchronously. It can do anything: either return
a value, throw an error, or return a promise.@paramargs Additional arguments, that will be passed to the callback.@returnsA Promise that is:
- Already fulfilled, if the callback synchronously returns a value.
- Already rejected, if the callback synchronously throws an error.
- Asynchronously fulfilled or rejected, if the callback returns a promise.
try(function mightThrow(): stringmightThrow)
  .Promise<string>.then<void, never>(onfulfilled?: ((value: string) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(result: stringresult => {
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Result:', result: stringresult);
  })
  .Promise<void>.catch<void>(onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
Attaches a callback for only the rejection of the Promise.
@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of the callback.
catch(err: anyerr => {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error('Caught error:', err: anyerr.message);
  });
JavaScript

In this example, Promise.try() ensures that if mightThrow() throws an error, it will be caught in the .catch() block, making it easier to handle both sync and async errors in one place.

Promise.withResolvers()

This method creates a new promise along with its associated resolve and reject functions, and returns them in a convenient object. This is used, for example, when you need to create a promise but resolve or reject it later from outside the executor function.

const { const promise: Promise<any>promise, const resolve: (value: any) => voidresolve, const reject: (reason?: any) => voidreject } = var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.PromiseConstructor.withResolvers<any>(): PromiseWithResolvers<any>
Creates a new Promise and returns it in an object, along with its resolve and reject functions.
@returnsAn object with the properties `promise`, `resolve`, and `reject`.

```ts
const { promise, resolve, reject } = Promise.withResolvers<T>();
```
withResolvers();

function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout)
setTimeout(() => {
  const resolve: (value: any) => voidresolve('Resolved successfully!');
}, 1000);

const promise: Promise<any>promise.Promise<any>.then<void, never>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
@paramonfulfilled The callback to execute when the Promise is resolved.@paramonrejected The callback to execute when the Promise is rejected.@returnsA Promise for the completion of which ever callback is executed.
then(value: anyvalue => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Success:', value: anyvalue);
});
JavaScript

In this example, Promise.withResolvers() gives you full control over when and how the promise is resolved or rejected, without needing to define the executor function inline. This pattern is commonly used in event-driven programming, timeouts, or when integrating with non-promise-based APIs.

Error Handling with Promises

Handling errors in Promises ensures your application behaves correctly in case of unexpected situations.

  • You can use .catch() to handle any errors or rejections that occur during the execution of Promises.
myPromise
  .then(result: anyresult => var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(result: anyresult))
  .catch(error: anyerror => var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error(error: anyerror)) // Handles the rejection
  .finally(error: anyerror => var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Promise completed')); // Runs regardless of promise resolution
JavaScript
  • Alternatively, when using async/await, you can use a try/catch block to catch and handle errors.
async function function performTask(): Promise<void>performTask() {
  try {
    const const result: anyresult = await myPromise;
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log(const result: anyresult);
  } catch (function (local var) error: unknownerror) {
    var console: Consoleconsole.Console.error(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
error(function (local var) error: unknownerror); // Handles any errors
  } finally {
    // This code is executed regardless of failure
    var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('performTask() completed');
  }
}

function performTask(): Promise<void>performTask();
JavaScript

Scheduling Tasks in the Event Loop

In addition to Promises, Node.js provides several other mechanisms for scheduling tasks in the event loop.

queueMicrotask()

queueMicrotask() is used to schedule a microtask, which is a lightweight task that runs after the currently executing script but before any other I/O events or timers. Microtasks include tasks like Promise resolutions and other asynchronous operations that are prioritized over regular tasks.

function queueMicrotask(callback: VoidFunction): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/queueMicrotask)
queueMicrotask(() => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Microtask is executed');
});

var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Synchronous task is executed');
JavaScript

In the above example, "Microtask is executed" will be logged after "Synchronous task is executed," but before any I/O operations like timers.

process.nextTick()

process.nextTick() is used to schedule a callback to be executed immediately after the current operation completes. This is useful for situations where you want to ensure that a callback is executed as soon as possible, but still after the current execution context.

process.nextTick(() => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Next tick callback');
});

var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Synchronous task executed');
JavaScript

setImmediate()

setImmediate() schedules a callback to be executed in the check phase of the Node.js event loop, which runs after the poll phase, where most I/O callbacks are processed.

setImmediate(() => {
  var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Immediate callback');
});

var console: Consoleconsole.Console.log(...data: any[]): void
[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
log('Synchronous task executed');
JavaScript

When to Use Each

  • Use queueMicrotask() for tasks that need to run immediately after the current script and before any I/O or timer callbacks, typically for Promise resolutions.
  • Use process.nextTick() for tasks that should execute before any I/O events, often useful for deferring operations or handling errors synchronously.
  • Use setImmediate() for tasks that should run after the poll phase, once most I/O callbacks have been processed.

Because these tasks execute outside of the current synchronous flow, uncaught exceptions inside these callbacks won't be caught by surrounding try/catch blocks and may crash the application if not properly managed (e.g., by attaching .catch() to Promises or using global error handlers like process.on('uncaughtException')).

For more information on the Event Loop, and the execution order of various phases, please see the related article, The Node.js Event Loop.

SebelumnyaPemrograman dan Panggilan Balik Asinkron JavaScriptBerikutnyaJelajahi Pengatur Waktu JavaScript
Waktu Membaca
9 mnt
Penulis
AK
Kontribusi
Sunting halaman ini
Daftar isi
  1. Promise States
  2. Basic Syntax of a Promise
  3. Handling Promises with .then(), .catch(), and .finally()
  4. Chaining Promises
  5. Using Async/Await with Promises
  6. Top-Level Await
  7. Promise-based Node.js APIs
  8. Advanced Promise Methods
  9. Promise.all()
  10. Promise.allSettled()
  11. Promise.race()
  12. Promise.any()
  13. Promise.reject() and Promise.resolve()
  14. Promise.try()
  15. Promise.withResolvers()
  16. Error Handling with Promises
  17. Scheduling Tasks in the Event Loop
  18. queueMicrotask()
  19. process.nextTick()
  20. setImmediate()
  21. When to Use Each