Un article pour parler des processus et sous-processus dans Node.js

Cet article vous donnera une compréhension approfondie des processus et sous-processus dans Node J'espère qu'il vous sera utile !

Process : module de processus

Le module de processus est un outil fourni par nodejs pour permettre aux développeurs d'interagir avec le processus actuel. Il fournit de nombreuses API pratiques. [Recommandations de didacticiel associées : Tutoriel vidéo Nodejs]

Partez de la documentation, obtenez un aperçu du léopard, puis comprenez et apprenez davantage le module de processus :

• Comment gérer les paramètres de commande ?
• Comment gérer le répertoire de travail ?
• Comment gérer les exceptions ?
• Comment gérer la sortie de processus ?
• Objet de flux standard de process
• Compréhension approfondie de process.nextTick

Comment gérer les paramètres de commande ?

Les paramètres de ligne de commande font référence à 2 aspects :

• paramètres transmis au nœud. Par exemple, dans node --harmony script.js --version, --harmony est le paramètre transmis à nodenode --harmony script.js --version 中，--harmony 就是传给 node 的参数
• 传给进程的参数。例如 node script.js --version --help 中，--version --help 就是传给进程的参数

它们分别通过 process.argv 和 process.execArgv 来获得。

如何处理工作目录？

通过process.cwd()可以获取当前的工作目录。

通过process.chdir(directory)可以切换当前的工作目录，失败后会抛出异常。实践如下：

function safeChdir(dir) {
    try {
        process.chdir(dir);
        return true;
    } catch (error) {
        return false;
    }
}

如何处理异常？

uncaughtException 事件

Nodejs 可以通过 try-catch 来捕获异常。如果异常未捕获，则会一直从底向事件循环冒泡。如是冒泡到事件循环的异常没被处理，那么就会导致当前进程异常退出。

根据文档，可以通过监听 process 的 uncaughtException 事件，来处理未捕获的异常：

process.on("uncaughtException", (err, origin) => {
    console.log(err.message);
});

const a = 1 / b;
console.log("abc"); // 不会执行

上面的代码，控制台的输出是：b is not defined。捕获了错误信息，并且进程以0退出。开发者可以在 uncaughtException 事件中，清除一些已经分配的资源（文件描述符、句柄等），不推荐在其中重启进程。

unhandledRejection 事件

如果一个 Promise 回调的异常没有被.catch()

et transmis au processus. Par exemple, dans node script.js --version --help, --version --help est le paramètre transmis au processus

Ils passent par processus respectivement. argv et process.execArgv pour obtenir.

Comment gérer le répertoire de travail ?

Vous pouvez obtenir le répertoire de travail actuel via process.cwd(). Vous pouvez changer de répertoire de travail actuel via process.chdir(directory), et une exception sera levée en cas d'échec. La pratique est la suivante :

process.on("unhandledRejection", (err, promise) => {
    console.log(err.message);
});

Promise.reject(new Error("错误信息")); // 未被catch捕获的异常，交由unhandledRejection事件处理

Comment gérer les exceptions ?

événement uncaughtException

Nodejs peut intercepter les exceptions via try-catch. Si l'exception n'est pas interceptée, elle remontera toujours du bas vers la boucle d'événements. Si l’exception qui remonte jusqu’à la boucle d’événements n’est pas gérée, le processus en cours se terminera anormalement.

Selon la documentation, vous pouvez gérer les exceptions non interceptées en écoutant l'événement uncaughtException du processus :

setTimeout(() => {
    console.log("我不会执行");
});

process.exit(0);

Pour le code ci-dessus, la sortie de la console est : b n'est pas défini. Le message d'erreur a été intercepté et le processus s'est terminé avec 0. Les développeurs peuvent effacer certaines ressources allouées (descripteurs de fichiers, descripteurs, etc.) dans l'événement uncaughtException, et il n'est pas recommandé de redémarrer le processus.

événement unhandledRejection

Si une exception de rappel Promise n'est pas interceptée par .catch(), alors l'événement unhandledRejection du processus sera déclenché :

setTimeout(() => {
    console.log("我不会执行");
});

process.exitCode = 1;

événement d'avertissement

Les avertissements ne font pas partie formelle du processus de gestion des erreurs Node.js et Javascript. Node.js peut émettre des alertes une fois qu'il détecte des pratiques de codage susceptibles d'entraîner des problèmes de performances, des défauts ou des risques de sécurité des applications.

Par exemple, dans le code précédent, si une exception de rappel de promesse non interceptée se produit, l'événement d'avertissement sera déclenché. Reportez-vous à l'explication vidéo avancée de nodejs : Entrer dans l'apprentissage

Comment gérer la sortie du processus ?

process.exit() vs process.exitCode🎜🎜🎜Un processus nodejs peut spécifier le code de sortie via process.exit() et quitter directement. 🎜Il n'est pas recommandé d'utiliser process.exit() directement🎜, ce qui empêcherait le traitement direct des tâches de la boucle d'événements et pourrait entraîner une troncature et une perte de données (comme l'écriture sur la sortie standard). 🎜

let hasSend = false;
process.on("beforeExit", () => {
    if (hasSend) return; // 避免死循环

    setTimeout(() => {
        console.log("mock send data to serve");
        hasSend = true;
    }, 500);
});

console.log(".......");
// 输出：
// .......
// mock send data to serve

🎜🎜La manipulation correcte et sûre consiste 🎜 à définir process.exitCode et à permettre au processus de se terminer naturellement. 🎜

process.stdin.setEncoding("utf8");

process.stdin.on("readable", () => {
    let chunk;
    while ((chunk = process.stdin.read()) !== null) {
        process.stdout.write(`>>> ${chunk}`);
    }
});

process.stdin.on("end", () => {
    process.stdout.write("结束");
});

🎜🎜événement beforeExit🎜🎜🎜Les événements utilisés pour gérer la sortie du processus sont : l'événement beforeExit et l'événement exit. 🎜🎜L'événement beforeExit est déclenché lorsque Node.js efface sa boucle d'événements et n'a plus de travail à planifier. Par exemple, si vous avez besoin de quelques opérations asynchrones avant de quitter, vous pouvez l'écrire dans l'événement beforeExit : 🎜

// 被拆分成2个函数执行
function BigThing() {
    doPartThing();

    process.nextTick(() => finishThing());
}

🎜Remarque : S'il s'agit d'une tâche asynchrone dans l'événement beforeExit, elle sera ajoutée à la file d'attente des tâches. À ce stade, une fois que la file d'attente des tâches a terminé toutes les tâches, l'événement beforeExit est à nouveau déclenché. Par conséquent, s’il n’est pas géré, 🎜une boucle infinie peut se produire🎜. Si exit() est appelé explicitement, cet événement ne sera pas déclenché. 🎜🎜🎜événement de sortie🎜🎜🎜Dans l'événement de sortie, seules les opérations synchrones peuvent être effectuées. Après avoir appelé l'écouteur d'événement « exit », le processus Node.js se terminera immédiatement, entraînant l'abandon de tout autre travail encore en file d'attente dans la boucle d'événements. 🎜🎜🎜🎜objet de flux standard du processus🎜🎜🎜

process 提供了 3 个标准流。需要注意的是，它们有些在某些时候是同步阻塞的（请见文档）。

• process.stderr：WriteStream 类型，console.error的底层实现，默认对应屏幕
• process.stdout：WriteStream 类型，console.log的底层实现，默认对应屏幕
• process.stdin：ReadStream 类型，默认对应键盘输入

下面是基于“生产者-消费者模型”的读取控制台输入并且及时输出的代码：

process.stdin.setEncoding("utf8");

process.stdin.on("readable", () => {
    let chunk;
    while ((chunk = process.stdin.read()) !== null) {
        process.stdout.write(`>>> ${chunk}`);
    }
});

process.stdin.on("end", () => {
    process.stdout.write("结束");
});

关于事件的含义，还是请看stream 的文档。

深入理解 process.nextTick

我第一次看到 process.nextTick 的时候是比较懵的，看文档可以知道，它的用途是：把回调函数作为微任务，放入事件循环的任务队列中。但这么做的意义是什么呢？

因为 nodejs 并不适合计算密集型的应用，一个进程就一个线程，在当下时间点上，就一个事件在执行。那么，如果我们的事件占用了很多 cpu 时间，那么之后的事件就要等待非常久。所以，nodejs 的一个编程原则是尽量缩短每一个事件的执行事件。process.nextTick 的作用就在这，将一个大的任务分解成多个小的任务。示例代码如下：

// 被拆分成2个函数执行
function BigThing() {
    doPartThing();

    process.nextTick(() => finishThing());
}

在事件循环中，何时执行 nextTick 注册的任务呢？请看下面的代码：

setTimeout(function() {
    console.log("第一个1秒");
    process.nextTick(function() {
        console.log("第一个1秒：nextTick");
    });
}, 1000);

setTimeout(function() {
    console.log("第2个1秒");
}, 1000);

console.log("我要输出1");

process.nextTick(function() {
    console.log("nextTick");
});

console.log("我要输出2");

输出的结果如下，nextTick 是早于 setTimeout：

我要输出1
我要输出2
nextTick
第一个1秒
第一个1秒：nextTick
第2个1秒

在浏览器端，nextTick 会退化成 setTimeout(callback, 0)。但在 nodejs 中请使用 nextTick 而不是 setTimeout，前者效率更高，并且严格来说，两者创建的事件在任务队列中顺序并不一样（请看前面的代码）。

子进程：child_process模块

掌握 nodejs 的 child_process 模块能够极大提高 nodejs 的开发能力，例如主从进程来优化 CPU 计算的问题，多进程开发等等。本文从以下几个方面介绍 child_process 模块的使用：

• 创建子进程
• 父子进程通信
• 独立子进程
• 进程管道

创建子进程

nodejs 的 child_process 模块创建子进程的方法：spawn, fork, exec, execFile。它们的关系如下：

• fork, exec, execFile 都是通过 spawn 来实现的。
• exec 默认会创建 shell。execFile 默认不会创建 shell，意味着不能使用 I/O 重定向、file glob，但效率更高。
• spawn、exec、execFile 都有同步版本，可能会造成进程阻塞。

child_process.spawn()的使用：

const { spawn } = require("child_process");
// 返回ChildProcess对象，默认情况下其上的stdio不为null
const ls = spawn("ls", ["-lh"]);

ls.stdout.on("data", data => {
    console.log(`stdout: ${data}`);
});

ls.stderr.on("data", data => {
    console.error(`stderr: ${data}`);
});

ls.on("close", code => {
    console.log(`子进程退出，退出码 ${code}`);
});

child_process.exec()的使用：

const { exec } = require("child_process");
// 通过回调函数来操作stdio
exec("ls -lh", (err, stdout, stderr) => {
    if (err) {
        console.error(`执行的错误: ${err}`);
        return;
    }
    console.log(`stdout: ${stdout}`);
    console.error(`stderr: ${stderr}`);
});

父子进程通信

fork()返回的 ChildProcess 对象，监听其上的 message 事件，来接受子进程消息；调用 send 方法，来实现 IPC。

parent.js 代码如下：

const { fork } = require("child_process");
const cp = fork("./sub.js");
cp.on("message", msg => {
    console.log("父进程收到消息：", msg);
});
cp.send("我是父进程");

sub.js 代码如下：

process.on("message", m => {
    console.log("子进程收到消息：", m);
});

process.send("我是子进程");

运行后结果：

父进程收到消息： 我是子进程
子进程收到消息： 我是父进程

独立子进程

在正常情况下，父进程一定会等待子进程退出后，才退出。如果想让父进程先退出，不受到子进程的影响，那么应该：

• 调用 ChildProcess 对象上的unref()
• options.detached 设置为 true
• 子进程的 stdio 不能是连接到父进程

main.js 代码如下：

const { spawn } = require("child_process");
const subprocess = spawn(process.argv0, ["sub.js"], {
    detached: true,
    stdio: "ignore"
});

subprocess.unref();

sub.js 代码如下：

setInterval(() => {}, 1000);

进程管道

options.stdio 选项用于配置在父进程和子进程之间建立的管道。 默认情况下，子进程的 stdin、 stdout 和 stderr 会被重定向到 ChildProcess 对象上相应的 subprocess.stdin、subprocess.stdout 和 subprocess.stderr 流。 这意味着可以通过监听其上的 data事件，在父进程中获取子进程的 I/O 。

可以用来实现“重定向”：

const fs = require("fs");
const child_process = require("child_process");

const subprocess = child_process.spawn("ls", {
    stdio: [
        0, // 使用父进程的 stdin 用于子进程。
        "pipe", // 把子进程的 stdout 通过管道传到父进程 。
        fs.openSync("err.out", "w") // 把子进程的 stderr 定向到一个文件。
    ]
});

也可以用来实现"管道运算符"：

const { spawn } = require("child_process");

const ps = spawn("ps", ["ax"]);
const grep = spawn("grep", ["ssh"]);

ps.stdout.on("data", data => {
    grep.stdin.write(data);
});

ps.stderr.on("data", err => {
    console.error(`ps stderr: ${err}`);
});

ps.on("close", code => {
    if (code !== 0) {
        console.log(`ps 进程退出，退出码 ${code}`);
    }
    grep.stdin.end();
});

grep.stdout.on("data", data => {
    console.log(data.toString());
});

grep.stderr.on("data", data => {
    console.error(`grep stderr: ${data}`);
});

grep.on("close", code => {
    if (code !== 0) {
        console.log(`grep 进程退出，退出码 ${code}`);
    }
});

更多node相关知识，请访问：nodejs 教程！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!