node 의 process 및 childprocess 모듈 학습 노트

일주일 동안 죽 을 힘 을 다 해 진행 한 후에 드디어 어 려 운 문 서 를 알 아 보고 자신의 이 해 를 여러분 에 게 공유 하려 고 합 니 다.여러분 도 의견 을 제시 해 주 셨 으 면 좋 겠 습 니 다.
프로 세 스 개념

Node.js 에서 모든 프로그램 은 프로 세 스 클래스 의 인 스 턴 스 대상 입 니 다

process 대상 을 사용 하여 응용 프로그램 을 대표 합 니 다.이것 은 전체 대상 으로 Node.jsy 응용 프로그램 과 이 프로그램 을 실행 하 는 사용자,환경 등 각종 정보의 속성,방법 과 사건 을 얻 을 수 있 습 니 다

프로 세 스 의 몇 가지 중요 한 속성
stdin 표준 입력 읽 을 수 있 는 흐름stdout 표준 입력 쓰기 가능 흐름stderr 표준 오류 출력 흐름
argv 단말기 입력 매개 변수 배열
env 운영 체제 환경 정보
pid 응용 프로그램 프로 세 스 idstdin 및 stdout

process.stdin.on('data', (chunk) => {
 process.stdout.write('       ' + chunk)
})

실행 결과

argv

console.log(process.env)

env:mac 터미널 에 export NODE 입력ENV=develop

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

프로 세 스 방법
process.memory Usage()메모리 사용 정보 보기

process.nextTick()현재 이벤트 loop 실행 완료 리 셋 함수

process.chdir()chdir 방법 은 Node.js 응용 프로그램 에서 사용 하 는 현재 작업 디 렉 터 리 를 수정 하 는 데 사 용 됩 니 다

process.cwd()프로 세 스 현재 작업 디 렉 터 리

process.kill()프로 세 스 죽 이기

process.uncaughtException()프로그램 이 캡 처 되 지 않 은 이상 을 던 졌 을 때 프로 세 스 대상 을 촉발 하 는 uncaughtException 이벤트

say() //     
process.on('uncaughtException',function(err){
 console.log('            :',err);
});

child_process
하위 프로 세 스 는 오늘 이야기 할 중점 입 니 다.저도 잘 모 르 겠 습 니 다.여러분 과 많은 교 류 를 하고 싶 습 니 다.
child_process 가 나타 난 배경
Node.js 에 서 는 하나의 스 레 드 만 이 모든 작업 을 수행 합 니 다.만약 에 특정한 작업 이 CPU 자원 을 대량으로 소모 해 야 할 경우 후속 작업 은 기 다 려 야 합 니 다.
Node.js 에서 child 를 제공 합 니 다.process 모듈 은 여러 개의 키 프로 세 스 를 열 수 있 고 여러 개의 키 프로 세 스 사이 에 메모리 공간 을 공유 할 수 있 으 며 하위 프로 세 스 의 상호 통신 을 통 해 정보의 교환 을 실현 할 수 있 습 니 다.
child_process 모듈 은 node 에 게 하위 프로 세 스 를 임의로 만 드 는 능력 을 줍 니 다.node 공식 문 서 는 childproces 모듈 은 운영 체제 에 비 치 는 네 가지 방법 을 제 시 했 습 니 다.모두 하위 프로 세 스 를 만 드 는 것 입 니 다.그러나 개발 자 에 게 만 이 몇 가지 방법의 api 는 약간 다르다.
child_process.exec(command[,options][,callback])시작
하위 프로 세 스 는 셸 명령 을 실행 합 니 다.스 크 립 트 셸 실행 결 과 를 리 셋 매개 변 수 를 통 해 가 져 올 수 있 습 니 다.
child_process.execfile(file[, args][, options][, callback])
exec 형식 과 달리 셸 명령 이 아 닌 실행 가능 한 파일 을 실행 합 니 다.
child_process.spawn(command[,args][,options])은 셸 명령 만 수행 할 뿐 실행 결 과 를 가 져 올 필요 가 없습니다.
child_process.fork(modulePath[,args][,options])node 사용 가능
실 행 된.js 파일 도 실행 결 과 를 가 져 올 필요 가 없습니다.fork 에서 나 온 하위 프로 세 스 는 node 프로 세 스 일 것 입 니 다.
spawn
문법:childprocess.spawn(command, [args], [options])

command 가 지정 해 야 할 매개 변 수 는 실행 해 야 할 명령 을 지정 합 니 다

args 배열 은 이 명령 을 실행 하 는 데 필요 한 모든 인 자 를 저장 합 니 다

options 매개 변 수 는 하나의 대상 으로 하위 프로 세 스 를 시작 할 때 사용 할 옵션 을 지정 합 니 다

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

사실 위 에 서 는 sdtio 배열 을 제외 하고 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 키 프로 세 스 열기

새로운 Node.js 프로 세 스 를 파생 시 키 고 IPC 통신 채널 을 구축 하여 지정 한 모듈 을 호출 합 니 다.이 채널 은 부모 프로 세 스 와 하위 프로 세 스 간 에 서로 정 보 를 보 낼 수 있 습 니 다

fork 방법 은 암시 적 으로 만 든 하위 프로 세 스 를 대표 하 는 ChildProcess 대상 을 되 돌려 줍 니 다

4

하위 프로 세 스 의 입 출력 작업 이 완료 되면 하위 프로 세 스 가 자동 으로 종료 되 지 않 습 니 다.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)
})

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.