Proceso hijo de Node.js

Node.js es un tiempo de ejecución de JavaScript que ofrece una variedad de módulos para trabajar. Por lo general, Node.js permite un rendimiento sin bloqueo de un solo subproceso, pero ejecutar un solo subproceso en una CPU no puede manejar el aumento de la carga de trabajo, por lo que el módulo child_process se puede usar para generar procesos secundarios. Los procesos secundarios se comunican entre sí mediante un sistema de mensajería integrado.

Las siguientes son las cuatro formas diferentes de crear un proceso secundario en Node.js:

• método de generación()
• método tenedor()
• método exec()
• método execFile()

Las formas mencionadas anteriormente se explican a continuación:

Método spawn(): este método genera un nuevo proceso usando el comando dado y los argumentos de la línea de comando en args. La instancia de ChildProcess implementa EventEmitterAPI, lo que nos permite registrar controladores para eventos en objetos secundarios directamente. Algunos eventos que se pueden registrar para su manejo con ChildProcess son salida, desconexión, error, cierre y mensaje.
Sintaxis:

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

Parámetros:

• comando: Acepta una string que es el comando a ejecutar.
• args: Lista de argumentos de string. El valor predeterminado es una array vacía.
• opciones:
  • shell: Acepta un valor booleano. Si es verdadero, ejecuta el comando dentro de un shell. Se puede especificar un shell diferente como una string. El valor predeterminado es falso, lo que implica que no hay shell. De forma predeterminada, spawn() no crea un shell para ejecutar el comando, por lo que es importante pasarlo como opción al invocar el proceso secundario.

  Se pueden usar opciones adicionales como cwd, env, argv0, stdio, etc. según los requisitos.

Valor devuelto: Devuelve un objeto ChildProcess.

Ejemplo:

const { spawn } = require('child_process');
const child = spawn('dir', ['D:\Test'], {shell: true});
child.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});
  
child.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});
  
child.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

Producción:

método fork(): child_process.fork() es un caso especial de child_process.spawn() donde el proceso padre y el hijo pueden comunicarse entre sí a través de send(). El fork() permite la separación de tareas de computación intensiva del bucle de eventos principal. Los procesos hijo son independientes del padre excepto el canal de comunicación IPC establecido entre ellos. Cada proceso tiene su propia memoria, por lo tanto, invocar una gran cantidad de procesos secundarios puede afectar el rendimiento de la aplicación. La opción de shell no es compatible con child_process.fork().

Sintaxis:

child_process.fork(modulePath[, args][, options])

Parámetros:

• modulePath: acepta una string que especifica el módulo que se ejecutará en el elemento secundario.
• args: Lista de argumentos de string.
• opciones: cwd, tachado, env, execPath, execArgv son algunas de las opciones disponibles para este método.

Valor devuelto: Devuelve una instancia de ChildProcess.

Ejemplo: Nombre de archivo: fork.js

// Write Javascript code here
var cp = require('child_process');
  
var child = cp.fork(__dirname + '/sub.js');
  
child.on('message', function(m) {
  console.log('Parent process received:', m);
});
  
child.send({ hello: 'from parent process' });
  
child.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

Nombre de archivo: sub.js

process.on('message', function(m) {
  console.log('Child process received:', m);
});
  
process.send({ hello: 'from child process' });

Producción:

Método exec(): este método crea primero un shell y luego ejecuta el comando.

Sintaxis:

child_process.exec(command[, options][, callback])

Parámetros:

• comando: acepta una string que especifica el comando a ejecutar con argumentos separados por espacios.
• opciones: algunas de las opciones disponibles son cwd, env, codificación, shell, tiempo de espera, etc.
• devolución de llamada: la función de devolución de llamada se llama cuando finaliza el proceso. Los argumentos de esta función son error, stdout y stderr respectivamente.

Valor devuelto: Devuelve una instancia de ChildProcess.

Ejemplo:

const { exec } = require('child_process');
  
// Counts the number of directory in 
// current working directory
exec('dir | find /c /v ""', (error, stdout, stderr) => {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`stdout: No. of directories = ${stdout}`);
  if (stderr!= "")
  console.error(`stderr: ${stderr}`);
});

Producción:

Método execFile(): La función child_process.execFile() no genera un shell de forma predeterminada. Es un poco más eficiente que child_process.exec() ya que el archivo ejecutable especificado se genera directamente como un nuevo proceso.

Sintaxis:

child_process.execFile(file[, args][, options][, callback])

Parámetros:

• archivo: Acepta una string que especifica el nombre o la ruta del archivo a ejecutar.
• args: Lista de argumentos de string.
• opciones: algunas de las opciones disponibles son cwd, env, codificación, shell, tiempo de espera, etc.
• devolución de llamada: la función de devolución de llamada se llama cuando finaliza el proceso. Los argumentos de esta función son error, stdout y stderr respectivamente.

Valor devuelto: Devuelve una instancia de ChildProcess.

Ejemplo:

const { execFile } = require('child_process');
  
// Executes the exec.js file
const child = execFile('node', ['exec.js'], 
        (error, stdout, stderr) => {
  if (error) {
    throw error;
  }
  console.log(stdout);
});

Producción: