Bagaimana untuk menunggu pelaksanaan sebelum nodejs ditutup

Node.js ialah persekitaran masa jalan JavaScript yang sangat popular yang boleh digunakan untuk membina aplikasi web berprestasi tinggi, alatan baris arahan, perangkak web, dsb. Dalam aplikasi Node.js, kita selalunya perlu melakukan beberapa operasi sebelum Node.js ditutup, seperti mengeluarkan sumber, menyimpan keadaan, dsb. Walau bagaimanapun, sebelum Node.js ditutup, kami perlu memastikan bahawa semua operasi tak segerak telah selesai, jika tidak kehilangan data atau ketidakkonsistenan mungkin berlaku. Jadi, bagaimana anda menunggu pelaksanaan sebelum Node.js ditutup? Artikel ini akan memperkenalkan anda kepada beberapa kaedah yang biasa digunakan.

Kaedah 1: Gunakan process.exitCode

Proses objek proses Node.js menyediakan atribut exitCode, yang digunakan untuk menentukan kod keluar aplikasi dan juga boleh dilaksanakan sebelum aplikasi keluar beberapa operasi. Sebagai contoh, kita boleh merangkum operasi tak segerak dalam objek Promise, dan kemudian tunggu penyiapan objek Promise dalam acara process.on('beforeExit'). Jika objek Promise diselesaikan, kita boleh menetapkan process.exitCode kepada 0, jika tidak, tetapkan kepada 1.

const fs = require('fs');

function readFile(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, (err, data) => {
      if (err) {
        reject(err);
      } else {
        resolve(data);
      }
    });
  });
}

process.on('beforeExit', async () => {
  try {
    const data = await readFile('data.txt');
    console.log(data.toString());
    process.exitCode = 0;
  } catch (err) {
    console.error(err);
    process.exitCode = 1;
  }
});

Kaedah 2: Gunakan Promise.all dan setTimeout

Kaedah biasa lain ialah menggunakan Promise.all dan setTimeout untuk menunggu operasi tak segerak selesai. Promise.all digunakan untuk melaksanakan satu set operasi tak segerak secara selari Apabila semua operasi tak segerak selesai, Promise.all akan mengembalikan objek Promise, dan kemudian kita boleh menunggu untuk tempoh masa dalam setTimeout, dan akhirnya keluar dari aplikasi dalam. fungsi panggilan balik setTimeout. Contohnya:

async function myApp() {
  const promises = [promise1(), promise2(), promise3()];
  await Promise.all(promises);
  setTimeout(() => {
    process.exit();
  }, 1000);
}

myApp();

Dalam contoh ini, kami mula-mula mentakrifkan satu set operasi tak segerak promise1, promise2 dan promise3, kemudian gunakan Promise.all untuk menunggu semua operasi selesai. Kemudian, kami menunggu selama 1 saat dalam setTimeout, dan akhirnya keluar dari aplikasi melalui kaedah process.exit() dalam fungsi panggil balik setTimeout.

Kaedah 3: Menggunakan async_hooks

Akhir sekali, kami memperkenalkan kaedah lanjutan: menggunakan async_hooks. Ini ialah modul terbina dalam Node.js untuk menjejaki kitaran hayat operasi tak segerak. Kita boleh mencipta sumber tak segerak melalui async_hooks dan menjejaki kitaran hayatnya. Khususnya, kita boleh menggunakan kaedah async_hooks.createHook() untuk mencipta cangkuk tak segerak, dan kemudian mentakrifkan sebelum, selepas, dan memusnahkan fungsi dalam cangkuk Fungsi ini dipanggil pada peringkat operasi tak segerak yang berbeza. Contohnya:

const async_hooks = require('async_hooks');

const resources = new Map();

const hook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    if (type === 'Promise') {
      resources.set(asyncId, 'Promise');
    }
  },
  destroy(asyncId) {
    resources.delete(asyncId);
  },
});

hook.enable();

async function myApp() {
  const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve();
    }, 1000);
  });
  await promise;
}

myApp();

process.on('beforeExit', () => {
  if (resources.size > 0) {
    console.warn('There are some unhandled promises!');
  } else {
    console.log('Everything is OK!');
  }
});

Dalam contoh ini, kami mula-mula mencipta cangkuk async dan menjejaki sumber Promise dalam fungsi init cangkuk. Seterusnya, dalam fungsi myApp kita mencipta objek Promise dan tunggu ia selesai selepas 1 saat. Akhir sekali, dalam acara process.on('beforeExit'), kami menyemak sama ada terdapat sumber Promise yang tidak diproses Jika ya, keluarkan mesej amaran, jika tidak, keluarkan mesej biasa.

Ringkasan

Artikel ini memperkenalkan beberapa cara untuk menunggu operasi tak segerak selesai dalam Node.js. Ia termasuk menggunakan process.exitCode, Promise.all dan setTimeout serta async_hooks. Dalam pembangunan sebenar, kita perlu memilih kaedah yang sesuai mengikut keperluan aplikasi dan memastikan semua operasi tak segerak dikendalikan dengan betul untuk memastikan integriti dan ketepatan data.

Atas ialah kandungan terperinci Bagaimana untuk menunggu pelaksanaan sebelum nodejs ditutup. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!