cron vs node-cron vs agenda vs later
Node.js 定时任务调度库选型指南
搜索包...
cronnode-cronagendalater类似的npm包:
Node.js 定时任务调度库选型指南

agenda、cron、later 和 node-cron 都是用于在 Node.js 环境中实现定时任务调度的 npm 包，但它们的设计目标、持久化能力、时间表达式语法和适用场景有显著差异。agenda 是一个基于 MongoDB 的持久化任务队列系统，支持任务重试、优先级和分布式调度；cron 和 node-cron 提供类似 Unix cron 的语法来定义周期性任务，但前者更轻量且仅支持基础功能，后者则提供更丰富的 API 和错误处理机制；later 专注于灵活的时间调度规则，支持文本和 cron 表达式，并能生成未来执行时间列表，但不直接提供任务执行器。这些库适用于从简单脚本到复杂后台作业系统的不同需求。

npm下载趋势
3 年
GitHub Stars 排名
统计详情
npm包名称
下载量
Stars
大小
Issues
发布时间
License
cron4,515,0298,897161 kB192 个月前MIT
node-cron2,303,5293,225221 kB277 个月前ISC
agenda155,0129,623295 kB61 天前MIT
later35,0742,420-9810 年前MIT

Node.js 定时任务调度库深度对比：agenda vs cron vs later vs node-cron

在 Node.js 应用中，定时任务无处不在 —— 从每日数据备份到每分钟健康检查。但面对 agenda、cron、later 和 node-cron 这些看似相似的库，如何选型？本文从真实工程角度出发，深入比较它们的核心能力、适用边界和代码实践。

🗃️ 任务持久化与可靠性：是否需要“记住”任务？

agenda 是唯一内置持久化能力的库。它将任务元数据（如下次运行时间、重试次数）存入 MongoDB，即使服务重启，未完成的任务也不会丢失。

// agenda: 任务自动持久化到 MongoDB
const agenda = new Agenda({ db: { address: 'mongodb://localhost:27017/agenda' } });

agenda.define('send email', async (job) => {
  await sendEmail(job.attrs.data.to);
});

// 即使进程退出，任务仍会在指定时间恢复执行
agenda.schedule('in 1 hour', 'send email', { to: 'user@example.com' });
agenda.start();

cron、node-cron 和 later 均为内存调度器。一旦进程终止，所有计划任务立即消失，无法恢复。

// cron: 内存中调度，进程退出即失效
const CronJob = require('cron').CronJob;
new CronJob('0 0 * * *', () => {
  console.log('Daily cleanup');
}, null, true);

// node-cron: 同样仅存在于内存
const cron = require('node-cron');
cron.schedule('0 0 * * *', () => {
  console.log('Daily cleanup');
});

// later: 仅计算时间，不执行任务，更无持久化
const later = require('later');
const schedule = later.parse.text('at 9:00 am');
// 需自行实现执行逻辑和状态管理

✅ 结论：若任务不能因服务重启而丢失（如支付对账、通知发送），必须选 agenda。否则，内存调度器足够。

⏰ 时间表达式灵活性：支持哪些调度规则？

cron 和 node-cron 使用标准 Unix cron 语法（5 或 6 位字段），但 node-cron 额外支持秒级精度（6 位）。

// cron: 标准 5 位 cron（分 时 日 月 周）
new CronJob('0 2 * * *', task); // 每天凌晨 2 点

// node-cron: 支持 6 位（秒 分 时 日 月 周）
cron.schedule('0 30 9 * * *', task); // 每天 9:30:00

later 提供最灵活的调度语法，支持自然语言描述和复杂规则组合。

// later: 支持文本解析和自定义约束
const schedule = later.parse.text('every 5 minutes between 9:00 and 17:00');
// 或使用 cron 表达式
const schedule2 = later.parse.cron('0 */2 * * *');

// 可生成未来 5 次执行时间
const times = later.schedule(schedule).next(5);

agenda 内部使用 human-interval 解析自然语言（如 'in 2 hours'），也支持 cron 表达式（通过 agenda.every('*/5 * * * *', ...)）。

// agenda: 支持自然语言和 cron
agenda.schedule('tomorrow at 9am', 'task');
agenda.every('*/10 * * * *', 'task'); // 每 10 分钟

✅ 结论：需要复杂调度规则（如“每月最后一个周五”）？选 later。只需标准 cron？cron 或 node-cron 足够。agenda 在两者间取得平衡。

🛠️ 任务执行与错误处理：崩溃了怎么办？

cron 的错误处理较弱。若任务抛出异常，整个 Node.js 进程可能崩溃（除非全局捕获）。

// cron: 未捕获异常会导致进程退出
new CronJob('* * * * *', () => {
  throw new Error('Oops!'); // 危险！
});

node-cron 默认捕获任务异常并记录，不会中断调度器或其他任务。

// node-cron: 异常被隔离
cron.schedule('* * * * *', () => {
  throw new Error('Safe!'); // 仅当前任务失败，调度器继续运行
});

agenda 提供完善的重试机制。任务失败后可自动重试（默认 0 次，可配置），并记录失败原因。

// agenda: 配置重试策略
agenda.define('critical job', { maxConcurrency: 1, retryTimes: 3 }, async (job) => {
  await riskyOperation();
});

later 不涉及任务执行，因此无错误处理逻辑 —— 你需要自己包装 try/catch。

✅ 结论：任务可能失败且需自动恢复？选 agenda。只需避免进程崩溃？node-cron 更安全。cron 适合可控的简单任务。

🧩 架构集成：如何嵌入现有系统？

agenda 本质是一个任务队列系统，支持多进程/多服务器共享任务池（通过同一 MongoDB 实例），天然适合分布式环境。

// 多个服务实例可同时消费同一任务队列
const agenda1 = new Agenda({ db: { address: 'shared-mongo' } });
const agenda2 = new Agenda({ db: { address: 'shared-mongo' } });
// 两者会协调执行任务，避免重复

cron、node-cron 和 later 均为单机调度器。若部署多个实例，每个都会独立触发任务，导致重复执行。

// 在 3 个容器中运行以下代码 → 任务执行 3 次！
cron.schedule('0 0 * * *', () => {
  chargeMonthlyFee(); // 危险：可能重复扣费
});

✅ 结论：多实例部署？必须用 agenda（或自行实现分布式锁）。单机应用？其他库均可。

📦 依赖与运维成本

  • agenda 强依赖 MongoDB，增加基础设施复杂度。
  • cron 和 node-cron 无外部依赖，安装即用。
  • later 无依赖，但需自行实现任务触发和状态跟踪。

🆚 总结：关键差异速查表

特性agendacronlaternode-cron
持久化✅ (MongoDB)❌❌❌
分布式支持✅❌❌❌
时间表达式自然语言 + cron标准 cron (5 位)文本 + cron + 自定义cron (6 位，含秒)
错误隔离✅ (重试机制)❌❌ (需自行处理)✅ (捕获异常)
外部依赖MongoDB无无无
适用场景关键后台作业、分布式系统简单单机脚本调度规则计算引擎健壮的单机定时任务

💡 最终建议

  • 构建 SaaS 后台或微服务？ → 用 agenda。持久化和分布式能力值得 MongoDB 的开销。
  • 写一个本地数据抓取脚本？ → 用 node-cron。秒级精度和错误隔离让开发更安心。
  • 需要解析“每季度第一个周一”这类规则？ → 用 later 计算时间点，再用 setTimeout 执行。
  • 快速验证一个想法？ → 用 cron。零配置，几行代码搞定。

记住：没有“最好”的库，只有“最合适”当前场景的工具。根据任务的关键性、部署环境和维护成本做选择，才能避免过度设计或埋下隐患。

如何选择: cron vs node-cron vs agenda vs later
  • cron:

    选择 cron 如果你只需要一个轻量级、无依赖的定时器，用于在单个 Node.js 进程中按 cron 表达式执行简单任务。它 API 极简，适合快速原型或小型脚本，但缺乏任务持久化、错误隔离和高级控制（如手动启动/停止之外的动态管理）。当项目对资源敏感且任务失败可接受时，它是合适的选择。

  • node-cron:

    选择 node-cron 如果你需要比 cron 更健壮的错误处理、更清晰的任务生命周期控制（如 start/stop/restart）以及对秒级精度的支持，同时仍希望保持轻量且无需外部数据库。它适合中等复杂度的定时任务场景，例如定期拉取数据、健康检查或缓存刷新，尤其当你需要确保任务异常不会导致整个调度器崩溃时。

  • agenda:

    选择 agenda 如果你需要一个具备持久化存储、任务重试、优先级管理以及跨进程/服务器协调能力的完整任务队列系统。它依赖 MongoDB 存储任务状态，适合需要高可靠性和容错能力的生产环境，例如发送邮件、数据同步或定期清理等关键后台作业。但如果你不需要持久化或不想引入数据库依赖，它的开销可能过大。

  • later:

    选择 later 如果你的核心需求是解析和计算复杂的调度时间点（例如“每月最后一个工作日”或“每两小时一次但避开午夜”），并希望将调度逻辑与执行逻辑解耦。它本身不运行任务，而是提供时间计算工具，适合集成到自定义调度引擎中。但若你需要开箱即用的任务执行能力，应搭配其他库使用，或考虑其他选项。

与cron类似的npm包

cron 是一个用于 Node.js 的时间调度库，允许开发者根据 cron 表达式安排任务的执行。它提供了一种简单而强大的方式来定期执行任务，适用于需要定时执行的场景，比如定期发送电子邮件、清理数据库或执行数据备份等。虽然 cron 提供了强大的调度功能，但在 Node.js 生态系统中还有其他一些替代库可以实现类似的功能。以下是几个替代方案：

  • agenda 是一个轻量级的任务调度库，基于 MongoDB。它允许开发者使用简单的 API 定义和调度任务，并支持任务的重复执行、延迟执行和优先级管理。由于 agenda 使用 MongoDB 存储任务信息，因此它非常适合需要持久化任务的应用程序。如果你的应用需要复杂的任务调度和持久化功能，agenda 是一个不错的选择。
  • later 是一个灵活的调度库，支持多种时间格式和调度规则。它允许开发者使用简单的 JavaScript 对象定义复杂的调度规则，并提供了强大的解析和格式化功能。later 适合需要灵活调度的应用程序，尤其是当任务的执行时间不规则时。如果你需要一个可以处理复杂调度逻辑的库，later 是一个值得考虑的选项。
  • node-cron 是一个简单的任务调度库，灵感来自于 UNIX 的 cron。它允许开发者使用 cron 表达式轻松地安排任务，并支持定时执行和重复执行。node-cron 的 API 简单易用，适合需要基本调度功能的应用程序。如果你只需要一个简单的调度解决方案，node-cron 是一个理想的选择。

要查看 cron 与其他库的比较，请访问：比较 agenda vs cron vs later vs node-cron。

与node-cron类似的npm包

node-cron 是一个用于 Node.js 的定时任务调度库。它允许开发者使用类似于 Unix cron 的语法来设置和管理定时任务，能够在特定的时间间隔或特定的时间点执行函数。这个库非常适合需要定期执行某些操作的场景，比如定时备份、数据抓取或发送定期报告等。

虽然 node-cron 提供了强大的定时任务调度功能，但在 Node.js 生态系统中还有其他一些库可以作为替代方案。以下是几个常见的替代库：

  • cron 是一个功能强大的定时任务调度库，提供了类似于 Unix cron 的功能。与 node-cron 类似，cron 允许开发者使用 cron 表达式来定义任务的执行时间。它的灵活性和强大功能使其适合于需要复杂调度的应用程序。如果你需要更高级的调度功能，cron 是一个不错的选择。
  • node-schedule 是另一个用于 Node.js 的定时任务调度库。与 node-cron 和 cron 不同，node-schedule 提供了一种更灵活的调度方式，允许开发者使用 JavaScript 的 Date 对象来设置任务的执行时间。它适合于需要在特定时间点或特定条件下执行任务的场景。如果你的调度需求比较复杂，node-schedule 可能会更符合你的需求。

要查看 node-cron 与 cron 和 node-schedule 的比较，请访问：比较 cron vs node-cron vs node-schedule。

与agenda类似的npm包

agenda 是一个用于 Node.js 的轻量级任务调度库。它允许开发者使用 MongoDB 来存储和调度任务，提供了一种简单而灵活的方式来处理定时任务和后台作业。虽然 agenda 提供了强大的任务调度功能，但在 Node.js 生态系统中还有其他库可以作为替代方案。以下是一些替代库：

  • bull 是一个功能强大的任务和消息队列库，基于 Redis 构建。它支持优先级、延迟和重复任务等高级功能，非常适合需要处理大量任务的应用程序。Bull 的设计旨在提供高性能和可靠性，尤其适合需要处理复杂工作流和任务调度的场景。如果你的应用需要高吞吐量和强大的任务管理功能，Bull 是一个理想的选择。
  • node-schedule 是一个基于 cron 表达式的任务调度库，允许开发者在 Node.js 中轻松地安排定时任务。它的 API 简单易用，适合需要在特定时间或间隔执行任务的应用。与 agenda 和 bull 不同，node-schedule 更加专注于简单的定时任务调度，而不是任务队列或后台作业处理。如果你的需求主要是定时执行任务，node-schedule 是一个不错的选择。

要查看 agenda 与 bull 和 node-schedule 的比较，请访问：比较 agenda vs bull vs node-schedule。

与later类似的npm包

later 是一个用于在 Node.js 应用程序中处理定时任务的库。它提供了一种灵活的方式来安排和执行定时任务，支持多种时间格式和调度选项。虽然 later 提供了强大的定时任务调度功能，但在 Node.js 生态系统中还有其他类似的库可以选择。以下是一些替代方案：

  • agenda 是一个基于 MongoDB 的轻量级任务调度库，适用于 Node.js 应用程序。它允许开发者使用简单的 API 来安排和执行任务，支持重复任务和延迟任务。由于其与 MongoDB 的紧密集成，agenda 特别适合需要持久化任务和调度的应用程序。如果你的应用需要一个强大的任务调度解决方案，并且你已经在使用 MongoDB，agenda 是一个不错的选择。
  • cron 是一个经典的定时任务调度库，模仿了 Unix 系统中的 cron 功能。它允许开发者使用 cron 表达式来定义任务的调度规则。由于其简单易用和广泛的社区支持，cron 是许多 Node.js 应用程序的首选定时任务解决方案。如果你熟悉 cron 表达式并希望快速设置定时任务，cron 是一个理想的选择。
  • node-schedule 是一个灵活的任务调度库，允许开发者使用 JavaScript 对象来定义任务的调度。它支持 cron 表达式和日期对象，提供了丰富的调度选项。node-schedule 适合需要灵活调度和简单 API 的应用程序。如果你希望在 Node.js 中使用简单的调度方法，node-schedule 是一个不错的选择。

查看比较：比较 agenda vs cron vs later vs node-schedule。

cron的README

cron for Node.js logo
cron is a robust tool for running jobs (functions or commands) on schedules defined using the cron syntax.
Perfect for tasks like data backups, notifications, and many more!

Cron for Node.js

Version Monthly Downloads Build Status CodeQL Status Coverage Renovate OpenSSF Scorecard Discord

🌟 Features

  • execute a function whenever your scheduled job triggers
  • execute a job external to the javascript process (like a system command) using child_process
  • use a Date or Luxon DateTime object instead of cron syntax as the trigger for your callback
  • use an additional slot for seconds (leaving it off will default to 0 and match the Unix behavior)

🚀 Installation

npm install cron

Table of Contents

  1. Features
  2. Installation
  3. Migrating
  4. Basic Usage
  5. Cron Patterns
  6. API
  7. Gotchas
  8. Community
  9. Contributing
  10. Acknowledgements
  11. License

⬆ Migrating

v4 dropped Node v16 and renamed the job.running property:

Migrating from v3 to v4

Dropped Node version

Node v16 is no longer supported. Upgrade your Node installation to Node v18 or above

Property renamed and now read-only

You can no longer set the running property (now isActive). It is read-only. To start or stop a cron job, use job.start() and job.stop().

v3 introduced TypeScript and tighter Unix cron pattern alignment:

Migrating from v2 to v3

Month & day-of-week indexing changes

  • Month Indexing: Changed from 0-11 to 1-12. So you need to increment all numeric months by 1.

  • Day-of-Week Indexing: Support added for 7 as Sunday.

Adjustments in CronJob

  • The constructor no longer accepts an object as its first and only params. Use CronJob.from(argsObject) instead.
  • Callbacks are now called in the order they were registered.
  • nextDates(count?: number) now always returns an array (empty if no argument is provided). Use nextDate() instead for a single date.

Removed methods

  • removed job() method in favor of new CronJob(...args) / CronJob.from(argsObject)

  • removed time() method in favor of new CronTime()

🛠 Basic Usage

import { CronJob } from 'cron';

const job = new CronJob(
	'* * * * * *', // cronTime
	function () {
		console.log('You will see this message every second');
	}, // onTick
	null, // onComplete
	true, // start
	'America/Los_Angeles' // timeZone
);
// job.start() is optional here because of the fourth parameter set to true.

// equivalent job using the "from" static method, providing parameters as an object
const job = CronJob.from({
	cronTime: '* * * * * *',
	onTick: function () {
		console.log('You will see this message every second');
	},
	start: true,
	timeZone: 'America/Los_Angeles'
});

Note: In the first example above, the fourth parameter to CronJob() starts the job automatically. If not provided or set to falsy, you must explicitly start the job using job.start().

For more advanced examples, check the examples directory.

⏰ Cron Patterns

Cron patterns are the backbone of this library. Familiarize yourself with the syntax:

- `*` Asterisks: Any value
- `1-3,5` Ranges: Ranges and individual values
- `*/2` Steps: Every two units

Detailed patterns and explanations are available at crontab.org. The examples in the link have five fields, and 1 minute as the finest granularity, but our cron scheduling supports an enhanced format with six fields, allowing for second-level precision. Tools like crontab.guru can help in constructing patterns but remember to account for the seconds field.

Supported Ranges

Here's a quick reference to the UNIX Cron format this library uses, plus an added second field:

field          allowed values
-----          --------------
second         0-59
minute         0-59
hour           0-23
day of month   1-31
month          1-12 (or names, see below)
day of week    0-7 (0 or 7 is Sunday, or use names)

Names can also be used for the 'month' and 'day of week' fields. Use the first three letters of the particular day or month (case does not matter). Ranges and lists of names are allowed.
Examples: "mon,wed,fri", "jan-mar".

📖 API

Standalone Functions

  • sendAt: Indicates when a CronTime will execute (returns a Luxon DateTime object).

    import * as cron from 'cron';

const dt = cron.sendAt('0 0 * * *');
console.log(`The job would run at: ${dt.toISO()}`);

  • timeout: Indicates the number of milliseconds in the future at which a CronTime will execute (returns a number).

    import * as cron from 'cron';

const timeout = cron.timeout('0 0 * * *');
console.log(`The job would run in ${timeout}ms`);

  • validateCronExpression: Validates if a given cron expression is valid (returns an object with valid and error properties).

    import * as cron from 'cron';

const validation = cron.validateCronExpression('0 0 * * *');
console.log(`Is the cron expression valid? ${validation.valid}`);
if (!validation.valid) {
	console.error(`Validation error: ${validation.error}`);
}

CronJob Class

Constructor

constructor(cronTime, onTick, onComplete, start, timeZone, context, runOnInit, utcOffset, unrefTimeout, waitForCompletion, errorHandler, name, threshold):

  • cronTime: [REQUIRED] - The time to fire off your job. Can be cron syntax, a JS Date object or a Luxon DateTime object.

  • onTick: [REQUIRED] - Function to execute at the specified time. If an onComplete callback was provided, onTick will receive it as an argument.

  • onComplete: [OPTIONAL] - Invoked when the job is halted with job.stop(). It might also be triggered by onTick post its run.

  • start: [OPTIONAL] - Determines if the job should commence before constructor exit. Default is false.

  • timeZone: [OPTIONAL] - Sets the execution time zone. Default is local time. Check valid formats in the Luxon documentation.

  • context: [OPTIONAL] - Execution context for the onTick method.

  • runOnInit: [OPTIONAL] - Instantly triggers the onTick function post initialization. Default is false.

  • utcOffset: [OPTIONAL] - Specifies time zone offset in minutes. Cannot co-exist with timeZone.

  • unrefTimeout: [OPTIONAL] - Useful for controlling event loop behavior. More details here.

  • waitForCompletion: [OPTIONAL] - If true, no additional instances of the onTick callback function will run until the current onTick callback has completed. Any new scheduled executions that occur while the current callback is running will be skipped entirely. Default is false.

  • errorHandler: [OPTIONAL] - Function to handle any exceptions that occur in the onTick method.

  • name: [OPTIONAL] - Name of the job. Useful for identifying jobs in logs.

  • threshold: [OPTIONAL] - Threshold in ms to control whether to execute or skip missed execution deadlines caused by slow or busy hardware. Execution delays within threshold will be executed immediately, and otherwise will be skipped. In both cases a warning will be printed to the console with the job name and cron expression. See issue #962 for more information. Default is 250.

Methods

  • from (static): Create a new CronJob object providing arguments as an object. See argument names and descriptions above.

  • start: Initiates the job.

  • stop: Halts the job.

  • setTime: Modifies the time for the CronJob. Parameter must be a CronTime.

  • lastDate: Provides the last execution date.

  • nextDate: Indicates the subsequent date that will activate an onTick.

  • nextDates(count): Supplies an array of upcoming dates that will initiate an onTick.

  • fireOnTick: Allows modification of the onTick calling behavior.

  • addCallback: Permits addition of onTick callbacks.

Properties

  • isActive: [READ-ONLY] Indicates if a job is active (checking to see if the callback needs to be called).

  • isCallbackRunning: [READ-ONLY] Indicates if a callback is currently executing.

    const job = new CronJob('* * * * * *', async () => {
	console.log(job.isCallbackRunning); // true during callback execution
	await someAsyncTask();
	console.log(job.isCallbackRunning); // still true until callback completes
});

console.log(job.isCallbackRunning); // false
job.start();
console.log(job.isActive); // true
console.log(job.isCallbackRunning); // false

CronTime Class

Constructor

constructor(time, zone, utcOffset):

  • time: [REQUIRED] - The time to initiate your job. Accepts cron syntax or a JS Date object.

  • zone: [OPTIONAL] - Equivalent to timeZone from CronJob parameters.

  • utcOffset: [OPTIONAL] - Analogous to utcOffset from CronJob parameters.

💢 Gotchas

  • Both JS Date and Luxon DateTime objects don't guarantee millisecond precision due to computation delays. This module excludes millisecond precision for standard cron syntax but allows execution date specification through JS Date or Luxon DateTime objects. However, specifying a precise future execution time, such as adding a millisecond to the current time, may not always work due to these computation delays. It's observed that delays less than 4-5 ms might lead to inconsistencies. While we could limit all date granularity to seconds, we've chosen to allow greater precision but advise users of potential issues.

  • Using arrow functions for onTick binds them to the parent's this context. As a result, they won't have access to the cronjob's this context. You can read a little more in issue #47 (comment).

🤝 Community

Join the Discord server! Here you can discuss issues and get help in a more casual forum than GitHub.

🌍 Contributing

This project is looking for help! If you're interested in helping with the project, please take a look at our contributing documentation.

🐛 Submitting Bugs/Issues

Please have a look at our contributing documentation, it contains all the information you need to know before submitting an issue.

🙏 Acknowledgements

This is a community effort project. In the truest sense, this project started as an open source project from cron.js and grew into something else. Other people have contributed code, time, and oversight to the project. At this point there are too many to name here so we'll just say thanks.

Special thanks to Hiroki Horiuchi, Lundarl Gholoi and koooge for their work on the DefinitelyTyped typings before they were imported in v2.4.0.

⚖ License

MIT

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.