Detaillierte Erläuterung der Verwendung der Node-Module „process' und „child_process'.

Dieses Mal werde ich Ihnen die Vorsichtsmaßnahmen bei der Verwendung der Knotenprozesse- und Child_Process-Module ausführlich erläutern ein Blick.

Das Konzept des Prozesses

1. In Node.js ist jede Anwendung ein Instanzobjekt der Prozessklasse.

2. Verwenden Sie das Prozessobjekt, um die Anwendung darzustellen. Dies ist ein globales Objekt, über das Sie die Eigenschaften der Node.jsy-Anwendung sowie der Benutzer und der Umgebung abrufen können, die das Programm ausführen Ereignisse.

Mehrere wichtige Attribute im Prozess

1. stdin Standardeingabe lesbarer Stream

2. stdout Standardeingabe beschreibbarer Stream

3. stderr Standardfehlerausgabestream

4. Argv-Terminal-Eingabeparameter-Array

5. Env-Betriebssystemumgebungsinformationen

6. PID-Anwendungsprozess-ID

stdin und stdout

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

Laufergebnisse

argv

console.log(process.env)

env: Geben Sie export NODE_ENV=develop

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

im Mac-Terminal ein Prozessmethoden

1. process.memoryUsage() Informationen zur Speichernutzung anzeigen

2. process.nextTick() Führe die aktuelle Ereignisschleife nach der Ausführung aus Callback-Funktion

3. process.chdir() Die chdir-Methode wird verwendet, um das aktuelle Arbeitsverzeichnis zu ändern, das in Node.js-Anwendungen

4. Prozess verwendet wird. cwd( ) Das aktuelle Arbeitsverzeichnis des Prozesses

5. process.kill() beendet den Prozess

6. process .uncaughtException() löst das uncaughtException-Ereignis des Prozessobjekts aus, wenn die Anwendung eine nicht abgefangene Ausnahme auslöst

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

child_process

Der Teilprozess steht im Mittelpunkt der heutigen Diskussion. Es gibt einige Dinge, die ich nicht ganz verstehe. Ich hoffe, ich kann Ihnen mehr mitteilen

In Node.js führt nur ein Thread alle Vorgänge aus. Wenn ein Vorgang eine große Menge an CPU-Ressourcen erfordert, müssen nachfolgende Vorgänge warten.

In Node.js wird ein child_process-Modul bereitgestellt, über das mehrere untergeordnete Prozesse gestartet werden können, der Speicherplatz zwischen mehreren untergeordneten Prozessen gemeinsam genutzt werden kann und der Informationsaustausch durch die gegenseitige Kommunikation der untergeordneten Prozesse erreicht werden kann.

Das Modul „child_process“ gibt dem Knoten die Möglichkeit, untergeordnete Prozesse beliebig zu erstellen. Die offizielle Knotendokumentation gibt vier Methoden für das Modul „child_proces“ an, die tatsächlich untergeordnete Prozesse erstellen. Aber nur für Entwickler: Die APIs dieser Methoden sind etwas anders

child_process.exec(command[, options][, callback]) startet den untergeordneten Prozess

abgerufen werden child_process.execfile(file[, args][, options][, callback])

child_process.spawn(command[, args][, options]) führt nur einen Shell-Befehl aus und muss die Ausführungsergebnisse nicht abrufen

child_process.fork(modulePath[, args][, options]) kann den Knoten

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

Befehlsparameter, der angegeben werden muss und den auszuführenden Befehl angibt
Args-Array, das alle zum Ausführen des Befehls erforderlichen Parameter speichert

2. Der Parameter
options ist ein Objekt, mit dem die Optionen angegeben werden, die beim Starten des untergeordneten Prozesses verwendet werden

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，当父进程不存在时也可以独立存在
})

analysieren.

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

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')

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

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]);//在子进程中向主进程发送消息

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)
})

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同步执行一个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)
})

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)
})

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung der Node-Module „process' und „child_process'.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!