Procesos hijo

El módulo de procesos secundarios de Node.js (child_process) tiene dos funciones spawn y exec, mediante las cuales podemos iniciar un proceso secundario para ejecutar otros programas en el sistema.

La diferencia más significativa entre child_process.spawn y child_process.exec está en lo que spawn devuelve un stream y exec devuelve un buffer.

• Usa spawn cuando quieras que el proceso hijo devuelva datos binarios enormes a Node.
• Usa exec cuando quieras que el proceso hijo devuelva mensajes de estado simples.
• Usa spawn cuando quieras recibir datos desde que el proceso arranca.
• Usa exec cuando solo quieras recibir datos al final de la ejecución.

Un buen blog para revisar mas del tema:

Diferencia entre spawn y exec de child_process de NodeJS - michelletorres

Child Process

En node podemos crear procesos hijos que ejecuten cualquier accion de nuestro sistema operativo, como si nos encontraramos en la linea de comandos.

Podemos llamar a exec para ejecuciones sencillas:

const { exec } = require('child_process')
exec('ls', (e, stdout) => {
    (e) ?
    console.log(e) :
    console.log(stdout)
})

Podemos llamar a spawn para obtener el proceso: La ventaja de este enfoque es que obtienes mayor control del proceso, y del estado en el que se encuenta

const { spawn } = require('child_process')
const myprocess = spawn('ls')

process.stdout.on("data", data => console.log(data.toString()));
process.on("exit", () => console.log("process end"));

con eso funciona en Windows

let proceso = spawn('cmd.exe', ['/c','dir']);```

Funcionamiento de los child process
Un proceso es la ejecución de algo(programa, commando, etc) que terminara en un tiempo finito.

Cuando se ejecuta un programa estos corren sobre la terminal y cuando necesitan crear un nuevo proceso crean una nueva terminal(Parent shell).

Entonces al utilizar esto creamos un Chils shell que ejecutara cualquiere instrucción que le pasemos. Para corroborar esto podemos ejecutar.

const {exec, spawn} = require('child_process');

exec('ps -f',(err,stdout,stderr)=>{
    if(err){
        console.log('Tuvimos un error')
        return false
    }
    
    console.log(stdout)
})

Y nos mostrará algo así donde PID es Proces IDse liga con Process Parent ID.

En conclusión el módulo de Node funciona a nivel SO creando child shell en los que es posible ejecutar cualquier instrucción, programa, etc, cualquier instrucción que nuestro terminal ya posea.

Node nos permite ejecutar varios hilos de procesos desde el suyo propio, sin importar de que sea este proceso, es decir, puede ejecutar procesos de Python, otros procesos de Node u otro proceso que tengamos en nuestro sistema.
Para poder usar estos procesos usamos el modulo de child-process, este trae dos métodos que nos permitirá ejecutar los procesos que deseemos. El método exec y el método spawn.
El método exec nos permite ejecutar un comando en nuestro sistema, recibe como parametros el comando entero que deseemos y como segundo parámetro un callback con tres parámetros, un error, un stdout y un stderr.
El método spawn es parecido al método exec pero un poco más complejo, permitiéndonos conocer su estado y que datos procesa en cada momento del estado de comando ejecutado.

Mi código para hacer ping usando child_process

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

const ip = "8.8.8.8";

const ping = (address) => {
  return new Promise((resolve, reject) => {
    exec(`ping ${address}`, (error, stdout, stderr) => {
      if (error) {
        reject(error);
      } else {
        resolve(stdout);
      }
    });
  });
};

ping(ip)
  .then((result) => console.log(result))
  .catch((error) => console.error("Ocurrió un error: ", error.message));

Ahhhhhhhhhhh Node es un amor ❤❤, no tenia ni idea de que hacer algo como eso fuera tan sencillo!

#HailNodeJs ✋✋

Procesos hijo

Un proceso es algo que se ejecuta y termina de ejecutarse. Con child process podremos acceder a la terminal por medio de Node.js

const { exec } = require('child_process')

let processes = [
    'ls -la',
    'node consola.js'
]

exec(processes[1], (err, stdout, sterr) => {
    if (err) {
        console.error(err)
        return false
    }
    console.log(stdout)
})

También podemos ver a detalle cómo se maneja un proceso con el método spawn

const { exec, spawn } = require('child_process')

let processSpawn = spawn('ls', ['-la'])

console.log(processSpawn.pid)
console.log(processSpawn.connected)

processSpawn.stdout.on('data', (datos) => {
        console.log('¿Está muerto?')
        console.log(process.killed)
        console.log(datos.toString())
    }
)
processSpawn.on('exit', () => {
        console.log('El proceso termino')
        console.log(processSpawn.killed)
    }
)

 let proceso = spawn('cmd.exe', ['/c', 'dir']);

 console.log(proceso.pid);
 console.log(proceso.connected);

proceso.stdout.on('data',  (dato)  => {
    console.log('esta muerto el proceso???')
    console.log(proceso.killed);
    console.log(dato.toString());
})

proceso.on('exit', () => {
    console.log('el proceso termino');
    console.log('ahora si esta muerto el proceso???')
    console.log(proceso.killed);
})

Esto es muy potente!! Creo que incluso se pueden ejecutar otros programas, y puede ser muy util, tal vez para abrir un cliente de correo electronico, ejecutar una pista de audio etc…

Estuve intentando y con esta linea, puedes ejecutar google chrome

exec('start chrome');

Para windows se hace diferente, ya que dir no es un ejecutable.

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

exec("ls -ls", (err, stdout) => {
  console.log("\nExec example:\n");

  if (err) {
    console.log(err);
    return false;
  }
  console.log(stdout);
});

let process = spawn("ls", ["-la"]);
process.stdout.on("data", data => console.log(data.toString()));
process.on("exit", () =>
  console.log("process end; process.killed:", process.killed)
);

En la parte final de si el proceso termino, le sale undefined porque escribio “process” cuando debio de haber sido como “proceso”.

 const { exec, spawn } = require('child_process');

/*exec('dir', (err, stdout, sterr) => {
    if(err) {
        console.error(err);
        return false;
    }

    console.log(stdout);
})
 */

let proceso = spawn('cmd.exe', ['/c','dir']);

console.log(proceso.pid);
console.log(proceso.connected);


proceso.stdout.on('data', function(dato){
    console.log('Esta muerto?', proceso.killed);
    console.log(dato.toString());
})

proceso.on('exit', function() {
    console.log('el proceso termino');
})

Ese exec me ha recordado al -exec que tiene el comando find. Obviamente este exec de node es mucho más complejo pero la teoría es parecida

En esta clase se demuestra que no solo es programar, si no conocer la computación en general, como funciona un sistema operativo, una red, etc

//cuando corre el proceso la data que obtenga la vamos a mostrar
proceso.stdout.on('data', function(data) {
  //mediante la varaible proceso podemos acceder a sus metodos
  console.log('Process is killed?:', proceso.killed)
  console.log(data.toString()) //imprime la data
})


// justo es la ultima linea del proceso, al ejecutarse se imprime
proceso.on('exit', () => {
  console.log('El proceso terminó!') //avisa que el proceso termino
  console.log('Process is killed?:', proceso.killed) //pero aun no muere
})

Ahora funciona ls en Windows

Child process: devuelve un lista de objetos entre los cuales esta exec

exec: recibe el comando a ejecutar en el sistema operativo, recibe un callback

Un proceso hijo puede ejecutar un proceso de node, esto permite seguie haciando cosas por debajo usando node

HE aquí mi código!!

const { exec, spawn } = require('child_process');

/*exec('ls ', (error, stdOut) => {
    error ? console.log(error) : console.log(stdOut);
});
*/
let proceso = spawn('ls',['-la']);
console.log(proceso.pid);
console.log(proceso.connected);

proceso.stdout.on('data', (dato) => console.log(dato.toString()))
proceso.on('exit', () => console.log('Proceso terminado'))```

Procesos Hijo (Child Process)

Exiten dos funciones para ejecutar procesos secundarios (Procesos hijo ó child process)

Primero se debe llamar a el modulos de los child_process

const { exec, spawn } = require('child_process')

Exec

// Ejecutar comandos de consola
exec('ls -al', (e, stdout, stderr) => {
  if (e) {
    console.error(e)
    return false
  }
  console.log(stdout)
})

/* return: devuelve el comando ls -al de la consola
drwxrwxr-x  4 santiagobr santiagobr 4096 sep 27 23:21 .
drwxrwxr-x 13 santiagobr santiagobr 4096 oct  4 08:23 ..
drwxrwxr-x  8 santiagobr santiagobr 4096 oct  7 11:09 .git
drwxrwxr-x  5 santiagobr santiagobr 4096 oct  6 17:13 src
*/

// Ejecutar procesos por debajo de otros archivos
exec('node src/modules/console.js', (e, stdout, stderr) => {
  if (e) {
    console.error(e)
    return false
  }
  console.log(stdout)
})

/* return: Muestra lo que es llamado del archivo console.js
	Ver algo
	
	[ { a: 1, b: 'Z' }, { a: 2, b: 'Y' } ]
	┌─────────┬───┬─────┐
	│ (index) │ a │  b  │
	├─────────┼───┼─────┤
	│    0    │ 1 │ 'Z' │
	│    1    │ 2 │ 'Y' │
	└─────────┴───┴─────┘
	Función 1
	  Esto es de la función 1
	  Esto también de la 1
	  Función 2
	    Esto es de la función 2
	    Esto también es 2
	veces: 1
	veces: 2
	veces: 3
	veces: 1
	veces: 2
*/

Spawn

// Invocar procesos nuevos

let process = spawn('ls', ['-al'])
console.log(process.pid) // --> <id del proceso> 45780
console.log(process.connected) // --> <estado del proceso> 
  
process.stdout.on('data', (datas) => {
  console.log('¿Está muerto?')
  console.log(process.killed)
  console.log(datas.toString())
})

process.on('exit', () => {
  console.log('The End')
})

Los procesos hijo permiten tener el control de lo que sucede dentro de este proceso y su estado.

EXEC
Nos permite ejecutar cualquier comando en una terminal!
Vamos a usar lago de ES6 que es para desestructurar un objeto, y nmos vamos a traer EXCEC (2 formas)

En linux o mac exec(‘ls -la’, segundo parametro)
En windows exec(‘dir’, segundo parametro)
“spawn” para procesos mas complejos
Nos permite invocar un proceso nuevo de node js.
A diferencia de un exec solo ejecuta un comadno y ya esta a continuacion podemos invocar a procesos mas largos! Invocar un proceso nuevo y empezar a ver que sucede con ese proceso.
Done el resto de parametros deben ir en un array y no como antes
EXEC (‘ls -la’)
SAPWN (‘ls’ , [‘la’])

const { exec, spawn } = require('child_process')

exec('ls -la', (error, stdout, sterr) =>{
    if (error) {
        console.error(error)
        return false
    }
    console.log(stdout)
})

exec('node modulos/console.js', (error, stdout, sterr) =>{
    if (error) {
        console.error(error)
        return false
    }
    console.log(stdout)
})


let proceso = spawn('ls', ['-la'])

console.log(proceso)
console.group('DETALLE DEL PROCESO')
console.log(`ID: ${proceso.pid}`)

console.log(`CONNECTED: ${proceso.connected}`)
proceso.stdout.on('data', (dato) =>{
    console.log(`El proceso termino: ${proceso.killed}`)
    console.log(dato.toString())
})

proceso.stdout.on('exit', () =>{
    console.log('El proceso termino')
    console.log(proceso.killed)
    console.groupEnd()
})```

funciona en windows.

const { exec, spawn } = require('child_process');

/* exec('node modulos/consola.js', (err, stdout, sterr) => {
  if (err) {
    console.error(err);
    return false;
  }

  console.log(stdout);
}) */

let proceso = spawn('dir', ['-la']);

console.log(proceso.pid);
console.log(proceso.connected);

proceso.stdout.on('data', function (dato) {
  console.log('¿Esta muerto?');
  console.log(process.killed);
  console.log(dato.toString());
});

proceso.on('exit', function () {
  console.log('El proceso termino');
  console.log(proceso.killed);
})

😃

Ejecutar otros procesos con child_process

https://www.digitalocean.com/community/tutorials/how-to-launch-child-processes-in-node-js

Node puede ejecutar sus propios procesos y otros procesos del sistema al tiempo.
Esto se puede hacer levantando diferentes procesos.
La librería child_process nos permite realizar dicho proceso.
Con spawm se puede iniciar un nuevo proceso, así mismo se debe saber qué se pueden correr programas o otros procesos de código que tengamos en otros lenguajes de programación.

La razón por la que al profesor le salía undefined cuando imprimía el proceso dentro del evento “on” es porque le había puesto process en vez de proceso, recordemos que proceso es el nombre de la variable que declaramos arriba:

let proceso = spawn("ls", ["-la"]);

console.log(proceso.pid);
console.log(proceso.connected);

proceso.stdout.on("data", (dato) => {
  console.log(proceso.killed); // Aquí estaba el typo
  console.log(dato.toString());
});

proceso.on("exit", () => {
  console.log("El proceso termino");
  console.log(proceso.killed);
});

me parece muy importante, quiza tengas un modelo de pytorch que reciba una imagen por https, ejecutas y respondes con la salida del modelo 🤯

¿Hay alguna diferencia entre hilo y proceso? ¿Cuál es? ☹

Si estas estudiando JavaScript, sumate a este grupo! es para ayudarnos entre todos https://chat.whatsapp.com/HjdfwMOTkpV66fp4lxwinL

const { exec,spawn } = require('child_process')
/* Alternativa */
/* const exec = require('child_process).exec */

/* Ejecutar comandos del sistema */

function ejecutarConsol() {
    exec("node modules/consol.js", (error, stdout, sterr) => {
        if (error) {
            console.error(error)
            return false
        }
        console.log(stdout);
    })
}
function listar() {
    exec("ls -la", (error, stdout, sterr) => {
        if (error) {
            console.error(error)
            return false
        }
        console.log(stdout);
    })
}
/* Fin de ejecutar comandos del sistema  */

/* Ejecutar un proceso y guardarlo en una variable */
let proceso = spawn("ls",["-la"])

/* Obtener ID */
console.log(proceso.pid)
/* Saber si está conectado */
console.log(proceso.connected);

/* Obtener lo que devuelve el proceso */
proceso.stdout.on("data",(dato)=>{
    console.log(dato.toString())
})

/* Saber si el proceso terminó */
proceso.on("exit",(dato)=>{
    console.log("El proceso terminó")
    console.log(dato)
})

/* Saber si el proceso se murió */
console.log("El proceso murió?")
console.log(proceso.killed)

Este módulo nos permite ejecutar procesos o programas escuchando eventos del Node, bastante útil si necesitas levantar o matar servicios adicionales para tu programa.

En node podemos crear procesos hijos que ejecuten cualquier accion de nuestro sistema operativo, como si nos encontráramos en la linea de comandos. También puede ser otros lenguajes

Para ejecutar en la línea de comandos

const { exec } = require('child_process') // llamamos a la librería

exec('ls', (e, stdout) => {
    (e) ? // esto es un if ternario
    console.log(e) :
    console.log(stdout)
}) // ejectutamos la funcion, ponemos el comando
// y el callback, con el error y la salida principal estandar

De esta forma si tines un codigo que da un resultado pero no lo quieres migrar a node, lo puedes usar perfectamente

La ventaja de este enfoque es que obtienes mayor control del proceso, y del estado en el que se encuentra

Para ejecutar en la línea de comandos

const proceso = spawn('ls') // si vas añadir argumentos ponerlos en un array 
// podemos acceder a los parametros del proceso on un console.log
console.log(proceso)
// al ID del proceso
console.log(proceso.pid)
// si esta conectado
console.log(proceso.connected)

// con este comando traemos los datos en consola
proceso.stdout.on("data", ()=>{
 console.log(dato.toString()
console.log(process.killed)} // pregunta si el proceso esta muerto
 ) 

// detectar al acabar
proceso.on("exit", //callback //)

• Usa spawn cuando quieras que el proceso hijo devuelva datos binarios enormes a Node.
• Usa exec cuando quieras que el proceso hijo devuelva mensajes de estado simples.
• Usa spawn cuando quieras recibir datos desde que el proceso arranca.
• Usa exec cuando solo quieras recibir datos al final de la ejecución.

A partir de la versión 10 de NodeJS, se implemento una propiedad llamada promisify que permite convertir las funciones típicas de las funciones con callback y funciones con promesa. Lo proporciona con una interfaz sencilla donde solo debemos importar promisify desde util y luego pasar la función asincrona para convertirla a promesas.

Aquí les dejo el ejemplo:

const { exec } = require('child_process');
const { promisify } = require('util');

exec('ls -la', (err, stdout, stderr) => {
  if (err) {
    console.error(err);
    return false;
  }

  console.log(stdout);
});

(async function () {
  const execPromise = promisify(exec);
  try {
    const { stdout, stderr } = await execPromise('ls -la');
    console.log(stdout);
  } catch (err) {
    console.error(err);
  }
})();

Aquí les dejo una ejecución de un Script de Python de Forma Independiente (así se interrumpa el proceso principal, este continuará):

<
/* ChildProcess - Spawn: spawn(str command, [ list of args ], { object of options } ) */

const { spawn } = require('child_process')
const path = "D:/Laboral/Vitalbox/Proyectos/Clientes/Katia/Procesamiento Carga Masiva/main.py"
const python = spawn('python', [path], { stdio: 'ignore', detached: true })

// When the process start:
python.on('spawn', function () {
    console.log(`Python Process is already spawned!`)
})

// When the process launch an error:
python.on('error', function(err) {
    console.log(`Error al iniciar el subproceso: ${err}`)
})

// When a new data is received
python.on('data', function (data) {
    console.log(`Data: ${data}`)
})

// When the process is closed:
python.on('close', function(code) {
    console.log(`Python process close all stdio with code ${code}`)
})

// When the process exit:
python.on('exit', function(code) {
    console.log(`child process exited with code ${code}`)
})
>

Adicionalmente puedes referenciarte de aqui:
https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options

Donde encontraras todos las opciones de las cuales dispone el proceso hijo “spawn” para que puedas explotar todo su potencial!

Ejecutar un shell script con node:

const { exec } = require('child_process');

const myShellScript = exec('sh modulos/scriptBash.sh');
myShellScript.stdout.on('data', (data) => {
    console.log(data);
});

myShellScript.stderr.on('data', (data) => {
    console.error(data);
});

shell script contenido:

#!/bin/sh

echo "SOY UN SCRIPT BASH EJECUTADO" >> script.txt

En si que es lo que hace el stdout, entiendo que es una salida, pero se refiere a la salida de la información, o seria como el callback que nos regresa el resultado de la petición cuando hay alguna? en ese caso el on seria mas especifico con la info que se desea manejar.

Super interesante todo y cada dia aprendiendo un monton, pero estoy teniendo el siguiente problema.
estoy trabajando desde windows 10, VScode, node 10.15.3 logre solucionar ciertos detalles con la documentacion de node pero al correr nodemon solo me aparece

[nodemon] restarting due to changes…
[nodemon] starting node Modulos/procesosHijo.js
18220
false
Microsoft Windows [vers�o 10.0.17134.1006]
© 2018 Microsoft Corporation. Todos os direitos reservados.

y ya no puedo hacer nada mas

• Es muy común la desestructuración de objetos (ESMASCRIPT6) para la importación de módulos. Por ejemplo es lo mismo

  const { exec } = require('child_process');

  que

  const exec = require('child_process').exec;

Node js: puede ejecutar sus propios procesos y puede ejecutar otros procesos en el sistema( correr procesos hijos).

spawn: permite ejecutar procesos (comandos) y detectar el estado del proceso entre otros atributos.

El módulo child_process de Node.js proporciona una serie de funciones que permiten crear, manipular y ejecutar procesos secundarios. Algunas de las funciones más interesantes son:

• spawn(): Esta función es la más versátil de todas, ya que permite ejecutar cualquier comando o script en un proceso secundario.
• exec(): Esta función es similar a spawn(), pero solo permite ejecutar comandos del sistema operativo.
• fork(): Esta función crea un proceso secundario que es un clon del proceso principal.

Estas funciones se pueden utilizar para una gran variedad de tareas, como:

• Ejecutar tareas de larga duración en un proceso secundario para liberar el hilo principal.
• Comunicarse con otros procesos o sistemas.
• Ejecución de tareas en paralelo.

Algunos ejemplos de cómo utilizar estas funciones son:

• Para ejecutar un comando del sistema operativo:

const child = require('child_process');

// Ejecutar el comando `ls`
child.exec('ls', (err, stdout, stderr) => {
  if (err) {
    console.log(err);
    return;
  }

  console.log(stdout);
});

• Para ejecutar un script:

const child = require('child_process');

// Ejecutar el script `script.js`
child.spawn('node', ['script.js'], (err, stdout, stderr) => {
  if (err) {
    console.log(err);
    return;
  }

  console.log(stdout);
});

• Para crear un proceso secundario clonado:

const child = require('child_process');

// Crear un proceso secundario clonado
const child = child.fork();

// Escuchar los eventos del proceso secundario
child.on('message', (message) => {
  console.log(message);
});

// Enviar un mensaje al proceso secundario
child.send('Hola, mundo!');

En general, las funciones child_process son una herramienta muy poderosa que puede utilizarse para una gran variedad de tareas.

jo*** spawn es lo que yo uso en xmonad/haskell para poder ejecutar procesos, esto me ayuda a automatizar y tener shorcuts o keybinds personalizados en linux!!! OMG!!! Este curso es una locura.

Esto me permite poder hacer en segundos algo que a un usuario normal le tomaría horas, ya que hago que la máquina trabaje para mí en lugar de yo trabajar para la máquina, como los usuarios comunes hacen.

¿Me estás diciendo que puedo hacer esto con node?¿Y que puedo usar asincronismo?¿Y hacer lo que pueda imaginar en la web?

Conceptos:
stdout: es un concepto típico de los sistemas operativos Unix. Determina el destino del resultado de un programa o proceso, por defecto es la pantalla y se muestra el resultado en la consola de la terminal, sin embargo puede redirigirse hacia un archivo por ejemplo.
processSpawn: se refiere a una función que carga y ejecuta un nuevo proceso hijo.

No se entiende muy bien la clase, no explica que es la propiedad stdout ni otras propiedades

Para los que trabajan en Windows. aunque lo entendí a rasgos generales. Dejo lo avanzado de la clase.
child_process
exec => ejecutar comando del sistema operativo
spawn => ejecutar comandos del sistema operativos de manera que pueda manejar cuando inicia, terminte ,etc

const {exec, spawn} = require('node:child_process');
exec('node modulos/console.js',(err,stdout,sterr)=>{
    if(err){
        console.log(err);
        return false;
    }
    console.log(stdout);
});

let proceso=spawn('dir',['-af'],{shell:true});
// console.log(proceso.pid);
// console.log(proceso.connected);

proceso.stdout.on('data', (data) => {
  console.log('Esta activo el proceso?.');
  console.log(proceso.killed);
  console.log(data.toString());
});



proceso.on('exit',function(){
  console.log('El proceso termino..');
});

El profe cometió un typo, los que no se dieron cuenta, aquí les digo. el profe escribió “process.killed” en lugar de “proceso.killed”.

Entonces el resultado debió ser false y no undefined
como le salió al profe

Mi ejemplo con la ejecución de subprocesos:

Mi ejemplo del llamado con spawn

Mi ejemplo de uso de subprocesos asíncronos (multithread implementation)

SUSCRIPCION DE PLATZI GRATIS!!!
Ahora que tengo tu atención, paso un aporte y una consulta.

Estuve probado la ejecución de otros con spawn y algo muy interesante que encontré es que puedes pasarle opciones al spawn para que ejecute los comando en una instancia de la shell, lo cual nos permite hacer pipe (instrucción1 | instrucción2) en el comando que le mandamos a ejecutar. De igual forma paso otro metodo de ‘pipear’ por si a alguien le resulta mas comodo:
Aclaración, tuve que pasarle el tipo Buffer porque estoy usando TS

Metodo 1:

const proceso = spawn('node prueba.js | node otraPrueba.js',{
    shell:true,
    cwd:'../prueba_spawn'
  })

  proceso.stdout.on('data', (dato: Buffer) => {
    console.log('pasa por aqui')
    console.log(dato.toString())
  })

Metodo 2:

const salir = spawn('mkdir', ['prueba'])
  const listar = spawn('ls', ['-la'])
   salir.stdout.pipe(listar.stdin)

  listar.stdout.on('data', (dato: string)=>{
    console.log(dato.toString())
  })

Lo copado del metodo uno es que tambien se le puede pasar el parametro cwd y navegar hacia otro fichero para que se ejecute el spawn.

Por otro lado mi consulta es: siempre que necesitemos que salga un dato desde algun archivo externo, necesitamos hacer console.log() de el valor que requerimos?

ya que en esos archivos de prueba tengo esto

function sumar(a, b){
  return a + b
}
console.log(sumar(1, 2))

Ya que si no envolvía la ejecución de sumar no me retornaba nada el stdout.

Gracias platzinautas, exitos!!

Aquí pueden encontrar otros métodos de child process:

https://www.freecodecamp.org/news/node-js-child-processes-everything-you-need-to-know-e69498fe970a/

// Procesos hijo

// Procesos hijo que se utilizan bajo el monohilo para ejecutar procesos en segundo plano, dependiendo lo que se requiera

const { exec } = require(‘child_process’);
// nombra una constante con proceso hijo
const { spawn } = require(‘node:child_process’);

// linux exec(‘ls -la’)
// exec('node folder/file.js, --) comando
// exec(‘dir’, (err, stdout, sterr) => {
// if (err) {
// console.error(err);
// return false;
// }
// console.log(stdout);
// })

let process = spawn(‘dir’);
console.log(process.pid);

process.stdout.on(‘data’, function (data){
console.log(data.toString())
})

process.on(‘exit’, function(){
console.log(‘The process finish’)
console.log(process.killed)
})

El proceso que comenta Carlos de invocar una feature escrita en python, pero desde JS, se conoce como “Monkey”

Con esta clase, me hubiera ahorrado un montón de problemas un par de meses atrás…

Luego de probar distintas cosas ví que exec y spawn se ejecutan de manera asíncrona, por lo tanto me puse a pensar cómo hacer para esperar a que un proceso termine y luego ejecutar el otro. Quizás es un poco obvio pero me pareció bueno compartirlo 😄

const { exec, spawn } = require('child_process');

// Esto se ejecuta de forma asíncrona. Lo manda al event loop.
const execProcess = () => {
    return new Promise((resolve, reject) => {
        exec('ls -l', (err, stdout, sterr) => {
            if (err) reject(err.message);
            
            console.log(stdout);

            resolve("Proceso finalizado");
        });
    });
}

// Podemos ejecutar otros comandos en la terminal. Hasta podemos ejecutar ficheros ejecutables de otros lenguajes de programación.

const spawnProcess = () => {
    console.log("Inicio spawnProcess");

    // Ejecutar un proceso y hacerle un seguimiento
    let process = spawn('ls', ['-la']);

    // El proceso tiene muchísimas propiedades y métodos que podemos escuchar para realizar acciones en base a lo escuchado.
    process.stdout.on('data', (data) => {
        console.log(`¿Está muerto? ${process.killed}`);
        console.log(data.toString());
    });

    // El 'data' sería como el 'click' en addEventListener. Básicamente estamos haciendo un addEventListener al proceso diciendo que ejecute tal callback cuando el proceso devuelva * data *.

    // Lo mismo, podemos añadir un eventListener para cuando el proceso termine
    process.on('exit', () => {
        // console.log(`¿Está muerto? ${process.killed}`);
        console.log("Proceso terminado");
    });
}

// Esperamos a que termine el proceso de exec() y luego llamammos al proceso de spawn
execProcess()
    .then((message) => {
        console.log(message);
        spawnProcess();
    });

Este programa ejecuta un script de python desde node utilizando exec. Tiene esta idea algún uso practico, se utilizan cosas así ? disparar procesos que están escritos en otros lenguajes desde node ? alguien le ve un caso en que esta idea sirva ?

console.clear();
const { exec } = require('child_process');

function execPyProcess(pyFile) {
  const pyProcess = `python ${pyFile}`
  
  return new Promise((resolve, reject) => {
    exec(pyProcess, (error, stdout, stderr) => {
      if (error) reject(stderr);
      resolve(stdout);
    });
  })
}

// hello_world.py --> python script
// print('Hello World !!')

execPyProcess('hello_world.py')
.then(console.log)
.catch(console.error);

window
https://stackoverflow.com/questions/18334181/spawn-on-node-js-windows-server-2012

let process=spawn(‘cmd’, [’/c’, ‘dir’], { stdio: ‘inherit’})

Usando Figlet para dibujar en consola y esta clase escribí

console.log("Empecemos!: \n ");
const fL = {
	0: "4Max",
	1: "3D",
	2: "3DASCII",
	3: "3DDiagonal",
	4: "3x5",
	5: "4Max",
	6: "5LineOblique",
	7: "Acrobatic",
	8: "Alligator",
	9: "Alligator2",
	10: "Alpha",
	11: "Alphabet",
	12: "AMC3Line",
	13: "AMC3Liv1",
	14: "AMCAAA01",
	15: "AMCNeko",
	16: "AMCRazor",
	17: "AMCRazor2",
	18: "AMCSlash",
	19: "AMCSlider",
	20: "AMCThin",
	21: "AMCTubes",
	22: "AMCUntitled",
	23: "Arrows",
	24: "ASCIINewRoman",
	25: "Avatar",
	26: "ANSIRegular",
	27: "ANSIShadow",
};

try {
	const hola = "Platzi";
	const { exec } = require("child_process");
	const c = `figlet -f ${fL[27]} ${hola}`;
	const l = "figlet -l";
	function reinicia(hola) {
		//-- stdout = standard output, sterr = standar error
		exec(c, (err, stdout, sterr) => {
			if (err) {
				console.error(err);
				return false;
			}
			console.log(stdout);
			console.log(fL[0] + fL[1]+fL[2]+fL[3]+fL[4]+fL[5]+fL[6]+fL[8]+fL[9]);
			//reinicia(hola);
		});
	}
	reinicia(hola);

} catch (err) {
	console.error(
		"[-] " + err.message,
		"[-]:$$:[-] " + err.name,
		"[-] " + err.stack
	);
	console.error(
		"~ ~ ~ ~ ~ ~ ~ ~ ~[|-|~\44~|-|]",
		"CapturadoError",
		"[|-|~\44~|-|]~ ~ ~ ~ ~ ~ ~ ~ ~"
	);
}

![figlet](

si usan la consola cmder no tendran problemas nunca mas tratando de recordar si era un comando de windows o de linux en la terminal

Este child process tiene buena pinta para hacer backups de lo que sea con un schedule.

STDERR VS ERR

err <-- Es enviado al callback cuando haya un error en el código. Puede que se te haya olvidado un {}, un (), inicializar una variable, etc.

stderr <-- Todo es enviado al callback cuando el comando de por sí ha está enviando un error. Puede que dentro del código que estes corriendo como código hijo este haciendo una petición a una api, por ello, existirá un error. Sin embargo, ese error no fue por el código en sí sino por la petición en sí.

Me encantó esta parte, me gustaría ver que lo implementemos en un curso posterior a este.

Child process: es una libreria dentro del modulo de node js

Esta parte de procesos hijo está muy densa y con muchas posibilidades 🤯

No tenia ni idea que esto era posible. Excelente clase!

Estoy comenzando en el backend y esta funcionaldiad de exec me ha sorprendido, como es posible que pueda ejecutar un archivo o código que esté en otro directorio, es que esto es algo que usan los hackers?

Una característica increíble de node

toString

🤯

vuelvo mañana a ver si termino de entenderlo xD

return false

spawn

Utilicen git bash o hyper para hacerlo tal cual el profesor.

exec

spaw para windows es diferente, Doc de Node

En resumen, los procesos hijo quieren decir que puedo ejecutar unas cosas al tiempo que otras?

WOWW

Carlos ¿Qué sistema operativo utilizas?

Esto es demasiado bueno:O

Bieeeeeeeeeeeeeeeeeeeen esta clase fue genial esa no me la sabia

Para los que trabajan en windows el comando ls solo funciona dentro de powershell, si estan en cmd hay que usar dir

eeh super el primero que veo que usa linux, la mayoria usa mac

El módulo de procesos secundarios de Node.js (child_process) tiene dos funciones spawn y exec, mediante las cuales podemos iniciar un proceso secundario para ejecutar otros programas en el sistema.