ทำการดำเนินการล้างข้อมูลก่อน Node.js ออก

ฉันต้องการบอก Node.js ให้ทำอะไรบางอย่างก่อนที่มันจะออกมาเสมอไม่ว่าจะด้วยเหตุผลใดก็ตาม - Ctrl+ C, ข้อยกเว้นหรือเหตุผลอื่น ๆ

ฉันลองสิ่งนี้:

process.on('exit', function (){
    console.log('Goodbye!');
});

ฉันเริ่มต้นกระบวนการฆ่ามันและไม่มีอะไรเกิดขึ้น ฉันเริ่มต้นใหม่อีกครั้งกดCtrl+ Cและยังไม่มีอะไรเกิดขึ้น ...

UPDATE:

คุณสามารถลงทะเบียนตัวจัดการprocess.on('exit')และในกรณีอื่น ๆ ( SIGINTหรือข้อยกเว้นที่ไม่สามารถจัดการได้) เพื่อโทร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}));

สคริปต์ด้านล่างอนุญาตให้มีตัวจัดการเดียวสำหรับเงื่อนไขการออกทั้งหมด มันใช้ฟังก์ชั่นการโทรกลับเฉพาะแอปเพื่อดำเนินการล้างข้อมูลรหัสที่กำหนดเอง

cleanup.js

// Object to capture process exits and call app specific cleanup function

function noOp() {};

exports.Cleanup = function Cleanup(callback) {

  // attach user callback to the process event emitter
  // if no callback, it will still exit gracefully on Ctrl-C
  callback = callback || noOp;
  process.on('cleanup',callback);

  // do app specific cleaning before exiting
  process.on('exit', function () {
    process.emit('cleanup');
  });

  // catch ctrl+c event and exit normally
  process.on('SIGINT', function () {
    console.log('Ctrl-C...');
    process.exit(2);
  });

  //catch uncaught exceptions, trace, then exit normally
  process.on('uncaughtException', function(e) {
    console.log('Uncaught Exception...');
    console.log(e.stack);
    process.exit(99);
  });
};

รหัสนี้จะดักจับข้อยกเว้นที่ไม่ถูกตรวจจับCtrl+ Cและเหตุการณ์การออกปกติ จากนั้นจะเรียกใช้ฟังก์ชันการเรียกกลับการล้างข้อมูลผู้ใช้ทางเลือกเดียวก่อนออกจากการจัดการเงื่อนไขการออกทั้งหมดด้วยวัตถุเดียว

โมดูลเพียงแค่ขยายวัตถุกระบวนการแทนการกำหนดตัวปล่อยเหตุการณ์อื่น หากไม่มีการเรียกกลับเฉพาะแอพการล้างค่าเริ่มต้นจะไม่มีฟังก์ชั่น op นี้ก็เพียงพอสำหรับการใช้งานของฉันที่กระบวนการที่เด็กถูกทิ้งให้ทำงานเมื่อออกจาก+CtrlC

คุณสามารถเพิ่มกิจกรรมการออกอื่น ๆ เช่น SIGHUP ได้ตามต้องการ หมายเหตุ: สำหรับคู่มือ NodeJS SIGKILL ไม่สามารถมีผู้ฟังได้ รหัสทดสอบด้านล่างแสดงให้เห็นถึงวิธีการต่างๆในการใช้ cleanup.js

// test cleanup.js on version 0.10.21

// loads module and registers app specific cleanup callback...
var cleanup = require('./cleanup').Cleanup(myCleanup);
//var cleanup = require('./cleanup').Cleanup(); // will call noOp

// defines app specific callback...
function myCleanup() {
  console.log('App specific cleanup code...');
};

// All of the following code is only needed for test demo

// Prevents the program from closing instantly
process.stdin.resume();

// Emits an uncaught exception when called because module does not exist
function error() {
  console.log('error');
  var x = require('');
};

// Try each of the following one at a time:

// Uncomment the next line to test exiting on an uncaught exception
//setTimeout(error,2000);

// Uncomment the next line to test exiting normally
//setTimeout(function(){process.exit(3)}, 2000);

// Type Ctrl-C to test forced exit 

สิ่งนี้จับทุกเหตุการณ์ทางออกที่ฉันพบว่าสามารถจัดการได้ ดูเหมือนน่าเชื่อถือและสะอาดมาก

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

"exit" เป็นเหตุการณ์ที่ถูกทริกเกอร์เมื่อโหนดเสร็จสิ้นการวนซ้ำของเหตุการณ์ภายในมันจะไม่ถูกทริกเกอร์เมื่อคุณยุติกระบวนการภายนอก

สิ่งที่คุณกำลังมองหากำลังดำเนินการบางอย่างบน SIGINT

เอกสารที่http://nodejs.org/api/process.html#process_signal_eventsให้ตัวอย่าง:

ตัวอย่างการฟัง SIGINT:

// Start reading from stdin so we don't exit.
process.stdin.resume();

process.on('SIGINT', function () {
  console.log('Got SIGINT.  Press Control-D to exit.');
});

หมายเหตุ: สิ่งนี้ดูเหมือนจะขัดจังหวะ sigint และคุณจะต้องเรียกใช้ process.exit () เมื่อคุณเสร็จสิ้นด้วยรหัสของคุณ

function fnAsyncTest(callback) {
    require('fs').writeFile('async.txt', 'bye!', callback);
}

function fnSyncTest() {
    for (var i = 0; i < 10; i++) {}
}

function killProcess() {

    if (process.exitTimeoutId) {
        return;
    }

    process.exitTimeoutId = setTimeout(() => process.exit, 5000);
    console.log('process will exit in 5 seconds');

    fnAsyncTest(function() {
        console.log('async op. done', arguments);
    });

    if (!fnSyncTest()) {
        console.log('sync op. done');
    }
}

// https://nodejs.org/api/process.html#process_signal_events
process.on('SIGTERM', killProcess);
process.on('SIGINT', killProcess);

process.on('uncaughtException', function(e) {

    console.log('[uncaughtException] app will be terminated: ', e.stack);

    killProcess();
    /**
     * @https://nodejs.org/api/process.html#process_event_uncaughtexception
     *  
     * 'uncaughtException' should be used to perform synchronous cleanup before shutting down the process. 
     * It is not safe to resume normal operation after 'uncaughtException'. 
     * If you do use it, restart your application after every unhandled exception!
     * 
     * You have been warned.
     */
});

console.log('App is running...');
console.log('Try to press CTRL+C or SIGNAL the process with PID: ', process.pid);

process.stdin.resume();
// just for testing

เพียงแค่ต้องการพูดถึงdeathแพคเกจที่นี่: 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
})

io.jsมีexitและbeforeExitกิจกรรมซึ่งทำสิ่งที่คุณต้องการ

นี่เป็นแฮ็คที่ดีสำหรับ windows

process.on('exit', async () => {
    require('fs').writeFileSync('./tmp.js', 'crash', 'utf-8')
});

หลังจากเล่นกับคำตอบอื่น ๆ นี่คือทางออกของฉันสำหรับงานนี้ การใช้วิธีนี้จะช่วยให้ฉันจัดการการล้างข้อมูลส่วนกลางในที่เดียว

1. ฉันต้องการหาเส้นทางรหัสที่ออกทั้งหมดอื่น ๆ เพื่อรหัส 'ออก'

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

2. สิ่งที่ exitRouter เรียกใช้คือ process.exit ()

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

3. ที่ '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...

สิ่งที่เกิดขึ้นคือกระบวนการโหนดที่เริ่มต้นด้วยรหัส SIGINT จากนั้นจะประมวลผลเส้นทางไปยัง process.exit () และในที่สุดก็ออกจากด้วยรหัสทางออก 0

ในกรณีที่กระบวนการเกิดโดยกระบวนการโหนดอื่นเช่น:

var child = spawn('gulp', ['watch'], {
    stdio: 'inherit',
});

และคุณพยายามที่จะฆ่ามันในภายหลังผ่าน:

child.kill();

นี่คือวิธีที่คุณจัดการกับเหตุการณ์ [บนลูก]:

process.on('SIGTERM', function() {
    console.log('Goodbye!');
});