在尝试了其他答案之后，下面是我对这个任务的解决方案。实现这种方式可以帮助我将清理工作集中在一个地方，防止重复处理清理工作。

我想将所有其他退出代码路由到“退出”代码。

const others = [`SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`]
others.forEach((eventType) => {
    process.on(eventType, exitRouter.bind(null, { exit: true }));
})

exitRouter所做的是调用process.exit()

function exitRouter(options, exitCode) {
   if (exitCode || exitCode === 0) console.log(`ExitCode ${exitCode}`);
   if (options.exit) process.exit();
}

在'exit'上，使用一个新函数处理清理

function exitHandler(exitCode) {
  console.log(`ExitCode ${exitCode}`);
  console.log('Exiting finally...')
}

process.on('exit', exitHandler)

为了演示目的，这是我要点的链接。在文件中，我添加了一个setTimeout来伪造进程运行。

如果你运行node node-exit-demo.js，什么都不做，那么2秒后，你会看到日志:

The service is finish after a while.
ExitCode 0
Exiting finally...

否则，如果在服务结束之前，你按ctrl+C终止，你会看到:

^CExitCode SIGINT
ExitCode 0
Exiting finally...

发生的情况是Node进程最初以代码SIGINT退出，然后路由到process.exit()，最后以退出代码0退出。

只是想在这里提到死亡包:https://github.com/jprichardson/node-death

例子:

var ON_DEATH = require('death')({uncaughtException: true}); //this is intentionally ugly

ON_DEATH(function(signal, err) {
  //clean up code here
})

我需要在退出时做一个异步清理操作，这个问题的答案都不适合我。

所以我自己试了一下，最后发现了这个:

process.once('uncaughtException', async () => {
  await cleanup()

  process.exit(0)
})

process.once('SIGINT', () => { throw new Error() })

更新:

You can register a handler for `process.on('exit')` and in any other case(`SIGINT` or unhandled exception) to call `process.exit()`

process.stdin.resume();//so the program will not close instantly

function exitHandler(options, exitCode) {
    if (options.cleanup) console.log('clean');
    if (exitCode || exitCode === 0) console.log(exitCode);
    if (options.exit) process.exit();
}

//do something when app is closing
process.on('exit', exitHandler.bind(null,{cleanup:true}));

//catches ctrl+c event
process.on('SIGINT', exitHandler.bind(null, {exit:true}));

// catches "kill pid" (for example: nodemon restart)
process.on('SIGUSR1', exitHandler.bind(null, {exit:true}));
process.on('SIGUSR2', exitHandler.bind(null, {exit:true}));

//catches uncaught exceptions
process.on('uncaughtException', exitHandler.bind(null, {exit:true}));

只有在处理程序内部调用同步代码时，这才有效，否则它将无限期地调用处理程序

这将捕获我能找到的可以处理的每个退出事件。目前看来很可靠，也很干净。

[`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`].forEach((eventType) => {
  process.on(eventType, cleanUpServer.bind(null, eventType));
})

Async-exit-hook似乎是处理这个问题的最新解决方案。它是退出钩子的分叉/重写版本，在退出前支持异步代码。