No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Procesos hijo

15/31
Recursos

Aportes 69

Preguntas 20

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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

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

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

//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

En la parte final de si el proceso termino, le sale undefined porque escribio 鈥減rocess鈥 cuando debio de haber sido como 鈥減roceso鈥.

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

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

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

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(鈥榣s -la鈥, segundo parametro)
En windows exec(鈥榙ir鈥, segundo parametro)
鈥渟pawn鈥 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 (鈥榣s -la鈥)
SAPWN (鈥榣s鈥 , [鈥榣a鈥橾)

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

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.

<h3>Child Process</h3> <h4>Exet</h4>

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

<h4>Spawn</h4>

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 鈥渟pawn鈥 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锟給 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.

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(鈥榗md鈥, [鈥/c鈥, 鈥榙ir鈥橾, { stdio: 鈥榠nherit鈥檥)

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.

La raz贸n por la que al profesor le sal铆a undefined cuando imprim铆a el proceso dentro del evento 鈥渙n鈥 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);
});

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.

驴Hay alguna diferencia entre hilo y proceso? 驴Cu谩l es? 鈽

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.