Node.js process.nextTick(callback[, ...args])用法及代码示例

process.nextTick(callback[, ...args])

参数

• callback <Function>
• ...args <any> 调用 callback 时要传递的其他参数

process.nextTick() 将 callback 添加到“下一个滴答队列”。在 JavaScript 堆栈上的当前操作运行完成后且在允许事件循环继续之前，此队列已完全排空。如果要递归调用 process.nextTick() ，则可以创建无限循环。有关更多背景信息，请参阅Event Loop 指南。

import { nextTick } from 'node:process';

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callbackconst { nextTick } = require('node:process');

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callback

这在开发 API 时很重要，以便让用户有机会在构造对象之后但发生任何 I/O 之前分配事件处理程序：

import { nextTick } from 'node:process';

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.const { nextTick } = require('node:process');

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.

API 或者 100% 同步，或者 100% 异步，这一点非常重要。考虑这个例子：

// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!
function maybeSync(arg, cb) {
  if (arg) {
    cb();
    return;
  }

  fs.stat('file', cb);
}

此 API 很危险，因为在以下情况下：

const maybeTrue = Math.random() > 0.5;

maybeSync(maybeTrue, () => {
  foo();
});

bar();

不清楚是先调用foo() 还是bar()。

以下方法要好得多：

import { nextTick } from 'node:process';

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}const { nextTick } = require('node:process');

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}

何时使用queueMicrotask()对比process.nextTick()#

queueMicrotask() API 是 process.nextTick() 的替代方案，它还使用相同的微任务队列来延迟函数的执行，该微任务队列用于执行已解决的 promise 的 then、catch 和 finally 处理程序。在 Node.js 中，每次“下一个滴答队列”被排空时，微任务队列都会在之后立即被排空。

import { nextTick } from 'node:process';

Promise.resolve().then(() => console.log(2));
queueMicrotask(() => console.log(3));
nextTick(() => console.log(1));
// Output:
// 1
// 2
// 3const { nextTick } = require('node:process');

Promise.resolve().then(() => console.log(2));
queueMicrotask(() => console.log(3));
nextTick(() => console.log(1));
// Output:
// 1
// 2
// 3

对于大多数用户级用例，queueMicrotask() API 提供了一种可移植且可靠的延迟执行机制，该机制适用于多个 JavaScript 平台环境，应该优于 process.nextTick()。在简单的场景中，queueMicrotask() 可以是 drop-in 替代 process.nextTick() 。

console.log('start');
queueMicrotask(() => {
  console.log('microtask callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// microtask callback

两个 API 之间的一个 note-worthy 区别是 process.nextTick() 允许指定附加值，这些值将在调用延迟函数时作为参数传递。使用 queueMicrotask() 实现相同的结果需要使用闭包或绑定函数：

function deferred(a, b) {
  console.log('microtask', a + b);
}

console.log('start');
queueMicrotask(deferred.bind(undefined, 1, 2));
console.log('scheduled');
// Output:
// start
// scheduled
// microtask 3

处理下一个滴答队列和微任务队列中引发的错误的方式存在细微差别。队列中的微任务回调中抛出的错误应尽可能在队列中的回调中处理。如果不是，process.on('uncaughtException') 事件处理程序可用于捕获和处理错误。

如有疑问，除非需要 process.nextTick() 的特定函数，否则请使用 queueMicrotask() 。