Busca en todas las páginas de la documentación
Node programa el trabajo asíncrono en dos familias de colas: microtareas (Promises, queueMicrotask, process.nextTick) y macrotareas (temporizadores, setImmediate). El orden de vaciado explica los errores de temporización sutiles.
Hoja de trucos de ordenación (simplificada):
1. Ejecutar la pila de llamadas hasta que esté vacía
2. Vaciar TODAS las devoluciones de llamada de process.nextTick
3. Vaciar TODAS las microtareas (Promises, queueMicrotask)
4. Ejecutar UNA macrotarea (temporizador, E/S, setImmediate, ...)
5. Repetir desde el paso 2
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
setTimeout(() => console.log('timer'), 0);
// nextTick → promise → timerCuándo usarlo:
awaitnextTick, queueMicrotask y setImmediateimport { setTimeout, setImmediate } from 'node:timers';
async function chain(): Promise<void> {
console.log('A');
await Promise.resolve();
console.log('B');
}
chain();
Promise.resolve().then(() => console.log('C'));
process.nextTick(() => console.log('D'));
setTimeout(() => console.log('E'), 0);
console.log('F');
// A, F, D, C, B, E (B puede intercalarse con C dependiendo de la temporización de await)// Peligroso: nextTick recursivo agota la E/S
function spin(count: number): void {
if (count <= 0) return;
process.nextTick(() => spin(count - 1));
}
// spin(1_000_000); // Nunca hagas esto en producciónLo que esto demuestra:
A, F) se ejecuta antes que cualquier trabajo asíncrono en colanextTick precede a las microtareas de Promiseawait divide las funciones asíncronas en continuaciones de microtareasnextTick recursivo impide que se ejecuten las macrotareas (incluida la E/S)setImmediate, etc.process.nextTick es técnicamente independiente de la cola de microtareas de Promise, pero se ejecuta antes.queueMicrotask programa microtareas que cumplen con las especificaciones; prefiérelo a nextTick para aplazamientos genéricos.| API | Tipo de cola | Se ejecuta antes de |
|---|---|---|
process.nextTick | nextTick | Promises, temporizadores |
Promise.then / await | microtarea | Siguiente macrotarea |
queueMicrotask | microtarea | Siguiente macrotarea |
setTimeout / setInterval | macrotarea (temporizadores) | Siguiente ciclo de bucle |
setImmediate | macrotarea (comprobación) | Siguiente iteración después de la encuesta |
// Aplazamiento seguro: no anula la cola de Promise como nextTick
function defer(fn: () => void): void {
queueMicrotask(fn);
}
// Se ejecuta después del lote de E/S actual, no antes de otras microtareas
import { setImmediate } from 'node:timers';
function deferMacrotask(fn: () => void): void {
setImmediate(fn);
}process.nextTick recursivo - agota los temporizadores y la E/S indefinidamente. Solución: usa setImmediate para el procesamiento por lotes o un worker.await hace que el código sea "paralelo" - solo produce microtareas en el mismo hilo. Solución: usa workers para el paralelismo de CPU.nextTick con cadenas de Promise para hacks de ordenación - frágil en diferentes versiones de Node. Solución: reestructura con máquinas de estado explícitas o colas.try/catch alrededor de await en los manejadores de eventos.| Alternativa | Usar cuándo | No usar cuándo |
|---|---|---|
queueMicrotask | Aplazamiento conforme a las especificaciones después de la pila actual | Necesitas temporización de fase de comprobación (setImmediate) |
setImmediate | Procesar trabajo por lotes después de la encuesta de E/S | Necesitas ordenación de Promise antes de la siguiente macrotarea |
| Cola de trabajos (BullMQ) | Trabajo asíncrono entre procesos | Experimentos de ordenación en proceso |
Librerías de mutex async | Serializar el acceso al estado compartido | Aplazamiento simple de una sola vez |
Microtareas. Las continuaciones de .then, .catch, .finally y await utilizan la cola de microtareas.
API histórica que precede a las microtareas en Node. nextTick se ejecuta antes que las Promises; a veces se usa en los internos de los streams; evítalo en el código de la aplicación.
Todas ellas: la cola se vacía completamente antes de que comience la siguiente macrotarea.
Después: setImmediate es una macrotarea. Todas las microtareas pendientes se vacían primero.
Una función async siempre devuelve una Promise. El código después de await se programa como microtareas.
Las cadenas de microtareas infinitas pueden agotar la memoria o agotar la E/S, un riesgo similar al de nextTick recursivo.
Los navegadores carecen de process.nextTick y setImmediate. Las reglas de ordenación de setTimeout(0) vs Promise son similares.
Sí, se programa en la cola de microtareas para la iteración actual del bucle, después de que la pila de llamadas actual se vacíe.
Escribe pruebas de ordenación explícitas con node:test y arrays de registro, pero prefiere eliminar las dependencias de orden en el código de la aplicación.
Continuaciones de microtareas después de que la Promise se resuelva, luego más macrotareas para la E/S de socket subyacente.
No, esa es una API de navegador. Las microtareas de Node provienen de Promises y queueMicrotask.
Raramente; los internos heredados de los streams lo usaban por compatibilidad. El código de la aplicación debe usar queueMicrotask o setImmediate.
Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS activa), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.
Revisado por Chris St. John·Última actualización: 19 jul 2026