Node.js队列任务场景下同类功能函数的命名规范咨询

Great question—this is such a common pitfall when building job queue systems in Node.js, and clear naming goes a long way toward keeping your codebase maintainable as it grows. Let’s break down some best practices tailored to your scenario:

1. Use Action Prefixes to Clearly Separate Responsibilities #

The most straightforward approach is to prefix each function with a verb that describes its actual role:

• For functions that trigger/enqueue a job (like your doStuff), use prefixes like enqueue, schedule, or queue.
• For functions that process the actual work (like your actuallyDoStuff), use prefixes like process, handle, or execute.

This makes the purpose of each function obvious at a glance, even to developers new to your codebase. Here’s how that would look for your example:

// 实际执行耗时任务的处理函数
const processDoStuff = async (jobData) => {
  // 耗时处理代码
};

// 绑定队列处理器
const DO_STUFF_JOB_TYPE = 'do_stuff'; // 抽成常量避免拼写错误
queue.process(DO_STUFF_JOB_TYPE, async (job, done) => {
  try {
    await processDoStuff(job.data);
    done();
  } catch (err) {
    done(err);
  }
});

// 对外导出的入队触发函数
const enqueueDoStuff = async () => {
  const job = queue.create(DO_STUFF_JOB_TYPE, { /* 任务数据 */ });
  await job.save(); // 建议加await确保任务成功入队
};

module.exports = enqueueDoStuff;

2. Keep a Core Name, Add Role-Specific Suffixes #

If you want to keep the core action name consistent (since both functions are tied to the same "do stuff" task), add a suffix that describes the function’s role:

• For the trigger function: Keep it simple (e.g., doStuff) since this is what other modules will import and call.
• For the processing function: Add suffixes like Handler, Task, or Worker to indicate it’s the backend logic.

Example:

// 内部任务处理函数
const doStuffHandler = async (jobData) => {
  // 耗时处理代码
};

queue.process('do_stuff', async (job, done) => {
  try {
    await doStuffHandler(job.data);
    done();
  } catch (err) {
    done(err);
  }
});

// 对外的入队触发函数
const doStuff = async () => {
  const job = queue.create('do_stuff', { /* 任务数据 */ });
  await job.save();
};

module.exports = doStuff;

3. Align with Your Team’s Existing Naming Conventions #

If you’re working on a team, always prioritize any established conventions. For example:

• Some teams require all queue worker functions to end with Worker (e.g., DoStuffWorker).
• Others use queue as a prefix for trigger functions (e.g., queueDoStuff).

Following team norms ensures consistency across the codebase and reduces cognitive load for everyone.

Quick Bonus Tip #

Always extract your job type strings (like 'do_stuff') into constants. This prevents typos between the queue.create and queue.process calls, which can lead to silent failures where jobs are enqueued but never processed.

内容的提问来源于stack exchange，提问作者Thomas Groutars