Explication détaillée de l'utilisation des modules process et child_process de node

Cette fois, je vais vous apporter une explication détaillée de l'utilisation des modules process et child_process de node. Quelles sont les précautions lors de l'utilisation des modules process et child_process de node. Voici des cas pratiques. un regard.

La notion de processus

1. Dans Node.js chaque application est un objet instance de la classe de processus.

2. Utilisez l'objet processus pour représenter l'application. Il s'agit d'un objet global à travers lequel vous pouvez obtenir les attributs de l'application Node.jsy ainsi que l'utilisateur et l'environnement exécutant les méthodes et le programme. événements.

Plusieurs attributs importants dans le processus

1. Flux lisible d'entrée standard stdin

2. Flux de sortie inscriptible d'entrée standard stdout

3. Flux de sortie d'erreur standard stderr

4. Tableau de paramètres d'entrée du terminal argv

5. informations sur l'environnement du système d'exploitation env

6. ID du processus de candidature pid

stdin et stdout

process.stdin.on('data', (chunk) => {
 process.stdout.write('进程接收到数据' + chunk)
})

Résultats en cours

argv

console.log(process.env)

env : Saisissez export NODE_ENV=develop

console.log(process.env.NODE_ENV) //develop

dans le terminal mac Méthodes de processus

1. process.memoryUsage() Afficher les informations sur l'utilisation de la mémoire

2. process.nextTick() Exécuter la boucle d'événement en cours après l'exécution Fonction de rappel

3. process.chdir() La méthode chdir est utilisée pour modifier le répertoire de travail actuel utilisé dans les applications Node.js

4. processus. cwd( ) Le répertoire de travail actuel du processus

5. process.kill() tue le processus

6. process .uncaughtException() déclenche l'événement uncaughtException de l'objet processus lorsque l'application lève une exception non interceptée

say() //方法不存在
process.on('uncaughtException',function(err){
 console.log('捕获到一个未被处理的错误:',err);
});

processus_enfant

Le sous-processus est au centre de la discussion d'aujourd'hui. Il y a certaines choses que je ne comprends pas très bien. J'espère pouvoir communiquer davantage avec vous

. Arrière-plan où child_process apparaît

Dans Node.js, un seul thread effectue toutes les opérations. Si une opération nécessite une grande quantité de ressources CPU, les opérations suivantes doivent attendre.

Dans Node.js, un module child_process est fourni, grâce auquel plusieurs processus enfants peuvent être démarrés, l'espace mémoire peut être partagé entre plusieurs processus enfants et l'échange d'informations peut être réalisé grâce à la communication mutuelle des processus enfants.

Le module child_process donne au nœud la possibilité de créer des processus enfants de manière arbitraire. La documentation officielle du nœud donne quatre méthodes pour le module child_proces. Le mappage vers le système d'exploitation crée en fait des processus enfants. Mais pour les développeurs uniquement, les API de ces méthodes sont un peu différentes

child_process.exec(command[, options][, callback]) démarre le processus enfant
pour exécuter la commande shell. Le résultat de l'exécution du script shell peut être obtenu via le paramètre de rappel

child_process.execfile(file[, args][, options][, callback])
Différent du type exec, il n'exécute pas une commande shell mais un fichier exécutable

child_process.spawn(command[, args][, options]) exécute uniquement une commande shell et n'a pas besoin d'obtenir les résultats de l'exécution

child_process.fork(modulePath[, args][, options]) peut utiliser le nœud
pour exécuter le fichier .js, et il n'est pas nécessaire d'obtenir le résultat de l'exécution. Le processus enfant sortant du fork doit être un processus de nœud

spawn

Syntaxe : child_process.spawn(command, [args], [options])

1. paramètre de commande qui doit être spécifié, spécifiant la commande à exécuter

2. tableau args, qui stocke tous les paramètres requis pour exécuter la commande

3. Le paramètre

   options est un objet utilisé pour spécifier les options utilisées lors du démarrage du processus enfant

const { spawn } = require('child_process')
const path = require('path')
let child1 = spawn('node', ['test1.js', 'yanyongchao'], {
 stdio: ['pipe', 'pipe', 'pipe'], // 三个元素数组 下面会详解
 cwd: dirname, 子进程工作目录
 env: process.env, 环境变量
 detached: true // 如果为true，当父进程不存在时也可以独立存在
})

En fait, ce qui précède est facile à comprendre, à l'exception du tableau sdtio. Analysons ensemble stdio

. stdio

stdio是一个数组，用来设置标准输入，标准输出，错误输出。个人理解

pipe：父进程和子进程之间建立一个管道

主进程代码

const path = require('path')
const { spawn } = require('child_process')
let p = spawn('node', ['childs_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: ['pipe', 'pipe', process.stderr]
})
p.stdout.on('data', (data) => {
 console.log(data.toString())
}) 
// 这里用stdout原因： 子进程的数据流与常规理解的数据流方向相反，
// stdin：写入流，stdout、stderr：读取流。

子进程代码

process.stdout.write('asd')

如果在stdio中放一个流，process.stdout,process.stdin

主进程代码

const { spawn } = require('child_process')
const path = require('path')
// 如果放的是一个流，则意味着父进程和子进程共享一个流
const p = spawn('node', ['child_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: [process.stdin, process.stdout, process.stderr]
})

子进程代码

process.stdout.write('asd') //控制台会输出asd

ipc

主进程代码

const path = require('path')
const { spawn } = require('child_process')
let p = spawn('node', ['child_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: ['ipc', 'pipe', 'pipe']
})
p.on('message', (msg) => {
 console.log(msg)
})
p.send('hello chhild_process')

子进程代码

process.on('message', (msg) => {
 process.send('子进程' + msg)
})
// child.send(message,[sendHandle]);//在父进程中向子进程发送消息
// process.send(message,[sendHandle]);//在子进程中向主进程发送消息

detached模式

const { spawn } = require('child_process')
const fs = require('fs')
const path = require('path')
let out = fs.openSync(path.join(dirname, 'childs/msg.txt'), 'w', 0o666)
let p = spawn('node', ['test4.js'], {
 detached: true, //保证父进程结束，子进程仍然可以运行
 stdio: 'ignore',
 cwd: path.join(dirname, 'childs')
})
p.unref()
p.on('close', function() {
 console.log('子进程关闭')
})
p.on('exit', function() {
 console.log('子进程退出')
})
p.on('error', function(err) {
 console.log('子进程1开启失败' + err)
})

fork开启一个子进程

1. 衍生一个新的 Node.js 进程，并通过建立一个 IPC 通讯通道来调用一个指定的模块，该通道允许父进程与子进程之间相互发送信息

3. fork方法返回一个隐式创建的代表子进程的ChildProcess对象

5. 子进程的输入/输出操作执行完毕后，子进程不会自动退出，必须使用process.exit()方法显式退出

子进程代码

const { fork } = require('child_process')
const path = require('path')
let child = fork(path.join(dirname, 'childs/fork1.js'))
child.on('message', (data) => {
 console.log('父进程接收到消息' + data)
})
child.send('hello fork')
child.on('error', (err) => {
 console.error(err)
})

子进程代码

process.on('message', (m, setHandle) => {
 console.log('子进程接收到消息' + m)
 process.send(m) //sendHandle是一个 net.Socket 或 net.Server 对象
})

exec开启子进程

// exec同步执行一个shell命令
let { exec } = require('child_process')
let path = require('path')
// 用于使用shell执行命令, 同步方法
let p1 = exec('node exec.js a b c', {cwd: path.join(dirname, 'childs')}, function(err, stdout, stderr) {
 console.log(stdout)
})

execFile开启子进程

let { execFile } = require('child_process')
let path = require('path')
let p1 = execFile('node', ['exec.js', 'a', 'b', 'c'], {
 cwd: path.join(dirname, 'childs')
}, function(err, stdout, stderr) {
 console.log(stdout)
})

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

vuex的项目结构与配置介绍

vue-cli 3.0.x升级到webpack4后有哪些新特性

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!