Contenido del curso
Jesús Miguel Quinto Teran
Jesus Adrian Berrio Valdes
María Jimena Rodríguez Contreras
Contenido del curso
Jesús Miguel Quinto Teran
Jesus Adrian Berrio Valdes
María Jimena Rodríguez Contreras
Carlos Mario Benitez
Jimmy Buriticá Londoño
Alonso Fabricio Samanez Nuñez
Patricio Manuel Ugarte
Rodrigo Rodriguez
José Guillermo
María Sierra
Gustavo Gonzalez Montero
Luis Alejandro Nieto Ruth
Camilo José Mezú Mina
Andrés Felipe Lopez gomez
Hiram Rodriguez Gomez
![Francisco Garcia [C6]](https://static.platzi.com/media/avatars/avatars/garciafran_c845c2fe-2ea4-42db-a305-a7f4ef13b0fd.jpeg)
Francisco Garcia [C6]
Andres Ramirez Restrepo
Jimmy Buriticá Londoño
Juan Manuel Oyarzún Gajardo
María Jimena Rodríguez Contreras
Jonathan Sánchez Luna
Tomas Salina
Mauricio Carrasco
Andrés Muñoz
Tomás André Peñaloza Avilés
Maicol Gomez
Andrés Muñoz
Santiago Bastidas Rodríguez
Abigail Perez
Jose Manuel Montaño Saenz
Maria Elizabeth Minero Alvarenga
Johan Echeverri
Jose Daniel Molina
Carlos Nassif Trejo Garcia
Giovanni Aranda
Daniel Adolfo Ordoñez Rubio
Ramdhei López Arcila
Process
El objecto process es una instancia de EventEmitter; podemos suscribirnos a el para escuchar eventos de node.
UncaughtException: Permite capturar cualquier error que no fue caputurado previamente. Esto evita que Node cierre todos los hijos al encontrar un error no manejado.
process.on('uncaughtException', (error, origen) => console.log(error, origen));
exit: Se ejecuta cuando node detiene el eventloop y cierra su proceso principal.
process.on('exit', () => console.log('Adios'));
tambien podemos usar BeforeExit para antes de salir como lo dice
y tener en cuenta que una vez ejecutado el exit nos desconectamos del event loop y cualquier otra cosa dentro no se va a ejecutar
gracias
En el minuto 3:07 cuando el profesor habla sobre capturar promesas que se han rechazado, no se utiliza uncaughtRejection sino unhandleRejection
Bien por la aclaración 👍
Gracias
Algo muy interesante que también se puede hacer con process es tomar argumentos que le pases al ejecutar el programa. Por ejemplo si ejecutás:
node process.js "Patricio Manuel" Ugarte 27
Al invocar en mi código a process.argv, este almacenará un array cuyo dos primeros valores siempre serán:
Y el resto de los índices se irán ocupando con los valores que le pasamos en orden. En el ejemplo que di serían:
Nótese que usé comillas (dobles o simples es lo mismo) para indicar que el espacio entre mi primer nombre y mi segundo nombre forma parte de un único argumento, si no me los hubiera tomado como dos distintos. Y que el número también lo considerará como un String (Algo que podemos solucionar facilmente con un .parseInt()).
Para luego acceder a en nuestro código a los valores que les pasamos podemos hacer:
const [, , nombres, apellido, edad] = process.argv; console.log(nombres); //Imprimirá "Patricio Manuel" console.log(apellido); //Imprimirá "Ugarte" console.log(edad); //Imprimirá "27"
Donde estoy aprovechando el Array Matching de ES6 para guardar los datos que me interesan del Array process.argv en variables, para usar esos valores en mi código.
Para leer más sobre el módulo global process recomiendo la Documentación Oficial de NodeJS.
Gracias, no se de Node y este dato me gusta mucho.
Una librería que te permite manejar de forma robusta los argumentos pasados desde la terminal de comandos es yargs. Frameworks como Angular o React utilizan internamente estos mismos paquetes junto con cosas como el paquete colors, que permite trabajar con colores en consola. Puedes encontrarlos instalados dentro de la carpeta /node_modules.
En mi experiencia personal, yargs es muy potente, y he hecho aplicaciones para CLI robustas con interfaces complejas solamente con este paquete.
Process
Podremos entender y ver qué pasa con el Process, podremos escuchar señales, escuchar lo que necesitemos y después hacer cosas con ellos.
Podemos hacer require para obtener process
const process = require('process')
Pero lo anterior no es necesario, ya que process es una variable global.
process.on('uncaughtException', (err, origen) => { console.error('Se nos ha olvidado capturar un error') console.error(err) }) funNoExiste()
Solo una pequeña aclaración en el evento relacionado con las promesas. El nombre correcto es "unhandledRejection"
Muchas Gracias
Les comparto mis notas para que se ayuden con el estudio 🙌🔥 https://platzi.com/tutoriales/1759-fundamentos-node/9490-notas-curso-de-fundamentos-de-nodejs-notion/
Que bien muchas gracias
Experimentando en el código para entender la diferencia entre los eventos exit y beforeExit, descubrí algo que me pareció interesante.
Como bien dice el profe Carlos, exit cierra el Hilo Principal, y las funciones asíncronas que integremos, no se ejecutaran:
process.on('exit', () => { console.log("El Proceso acabó") setTimeout(() => { console.log("Esto no debe de verse, ya que ocurriría después de que el programa se cerró") }, 2000) })
Este console.log no va a ejecutarse
Pero con beforeExit es una historia muy diferente:
let x = -1 process.on(‘beforeExit’, () => { setTimeout(() => { if(x) { console.log(“El Proceso va a terminar”) console.log(“Esta funcion asíncrona se va a repetir…”) x++ } else { console.log(“Y repetir…”) } }, 2000) })
beforeExit ++no cierra++ el Hilo Principal, por lo que al detectar el evento y ejecutar la función asíncrona, el final del Hilo Principal se va a “posponer” para darle tiempo de concluir la función en el Thread Pool. Esto provocará que el evento beforeEnd se dispare nuevamente, haciendo que la función asíncrona se ejecute otra vez…y ciclando la aplicación.
El Proceso va a terminar Esta funcion asíncrona se va a repetir... Y repetir... Y repetir... Y repetir... Y repetir...
Muy utili la finalizacion de procesos.
//no se hace, ya que process pertenece los modulos globales, que ya vienen con node //const process = require('process'); //el proceso esta por terminar process.on('beforeExit', () => { console.log('El proceso ya casito termina'); }) //el proceso ha terminado //console.log(process.on('uncaughtException')); process.on('uncaughtRejection', (err, origen) => { console.error('se nos olvido captura el error'); console.error(err); }); //funcionQueNoExiste(); console.log('esto no sale') process.on('exit', () => { console.log('El proceso termino'); setTimeout(() => { console.log('este mensaje es invisible'); }, 500); }) setTimeout(() => { console.log('este mensaje es totalmente visible'); }, 500);
El evento exit se activa cuando el proceso está a punto de salir.
process.on ('exit', function () { console.log('Ultimo llamado antes de terminar el proceso') });
Exit puede ser util para guardar algún tipo de informe final antes de salir. Tendrán que ejecutarse procesos sincronos pues cualquier proceso asincrono no sera ejecutado.
El otro evento incorporado se llama uncaughException - se dispara cada vez que se produce una excepción que no se ha considerado. No es la forma ideal de manejar errores, pero puede ser muy útil como última línea de defensa si un programa necesita mantenerse en funcionamiento indefinidamente.
process.on ('uncaughtException', function (err) { console.error ('¡Se produjo un error no considerado!'); console.error (err.stack); });
Finalmente, el evento beforeExit se emite cuando Node.js vacía su ciclo y no tiene trabajo adicional que programar. Este evento si puede hacer llamadas asincronas puesto que genera que el proceso de Node.Js continue hasta terminar el nuevo evento.
Muy buena explicación
//const process = require('process') process.on('beforeExit', () =>{ console.log('Ey !! El proceso esta a punto de acabar') }) process.on('exit', () =>{ console.log('El proceso acabo') }) process.on('uncaughtException', (err) =>{ console.log(`Ocurio un error: ${err.message}`) }) //functionQueDaError()
gracias
Les dejo mi versión de la clase en donde además de manejar el uncaughtException, agrego ejemplo para unhandledRejection, además de manejar intencionalmente distintos tipos de declaración en las funciones, declarativas, anónimas y de flecha.
// const proc = require('process'); // Previous line commented because process is a global included into node core // As arrow function process.on('beforeExit', () => { console.log('Exiting...'); }); // As anonymous function process.on('exit', function () { console.log('Program terminated'); }); // ------------------------- EXCEPTION STUFF ---------------------------------- // Function declaration, as anonymous function const exceptionCatcher = function (error, origin) { console.error('Personalized error: ', error); console.error('Origin: ', origin); }; // Event handler pointing to exception catcher process.on('uncaughtException', exceptionCatcher); // * COMMENT NEXT LINE TO SEE UNHANDLED PROMISE BEHAVIOR ghostFunction(); // To provoque the uncaught exception, which ends the process // * COMMENT PREVIOUS LINE TO SEE UNHANDLED PROMISE BEHAVIOR console.log('This info is unaccesible if the exception was caught :D'); // --------------------------- PROMISE STUFF ---------------------------------- // Function declaration, as arrow function const rejectionCatcher = (error, origin) => { console.error('Personalized error: ', error); console.error('Origin: ', origin); }; // Event handler pointing to rejection catcher process.on('unhandledRejection', rejectionCatcher); function somePromiseFunction() { return new Promise((resolve, reject) => { if (false) resolve('Everything was OK'); else reject('Nothing was OK'); }); }; somePromiseFunction(); console.log('This info is accesible even if the rejection was caught :D');
Happy coding!
Algo gracioso ocurre si ponemos el setTimeout en el beforeExit:
process.on("beforeExit", () => { console.log("El proceso está por acabar"); setTimeout(() => { console.log("Esto si se va a ver"); }, 1000); });
Lo que estaremos creando es ni más ni menos que un bucle infinito.
Alguien sabe por qué?
Hice los mismo antes de leer esto y efectivamente entra en un bucle infinito, justo antes de apagar todo le dices a node manda al thread pool un console.log mas lo manda y de ahi continua hacia una orden que dice antes de salir asegúrate que el thread pool esta limpio, no lo esta hay un console.log lo limpia, y dice ok ahora si al exit pero beforeExit un console.log más… y así hasta el final de los tiempos… sera que cuenta como bug de node ? qué pasara si se lo crea como issue en el github de node ?
Hola! necesito una mano por favor... por alguna razón mi último console.log no se ejecuta a pesar de que se tiene el uncaughtExeption para recogerlo... que podría estar fallando?
process.on('beforeExit', ()=>{ console.log('El proceso casi termina'); }); process.on('exit', ()=>{ console.log('Tommy, el proceso acabó'); }); process.on('uncaughtException', (err, origen)=>{ console.error('Vaya, se nos ha olvidado capturar un error'); console.error(err); }); funcionquenoexiste (); console.log('Si el error no se recoje, esto no sale...');
Me pasa lo mismo, pero incluso en el ejemplo del profesor tampoco le sale el último log.
Prueba envolver el error en un try/catch sino esta dentro de un try catch el proceso se corta, lo que logras escuchando el uncaughtException es que node no haga crash, ósea que siga vivo manejando otros request pero el proceso se corta al menos que se maneje con un try/catch lo cual le encuentro sentido es como si node dijera: "Si quieren que esto continue inclusive con errores me ponen un try catch como firma que un humano estuvo por aquí"'.....
try { funcionquenoexiste(); } catch(error) { if (error instanceof ReferenceError) { console.log('Eres un error que soy conciente que estoy dejando continuar adelante...') } else { console.log('todos los demas errores no estan en lista a la perrera') throw error; } }
Process
Acceder al proceso de Node y entender todo lo que ocurre. Permite escuchar los eventos de la ejecución.
process.on('exit', () => { console.log('El proceso acabó') })
En este caso estamos escuchando el evento exit que permite saber cuando termina el proceso de ejecución y le estamos enviando un mensaje por consola.
Otro evento es el beforeExit que se ejecuta antes de que el proceso termine.
process.on('beforeExit', () => { console.log('El proceso va a terminar') })
En el caso que ocurra una excepción que no esta siendo capturada con un try/catch existe un evento para controlar esto.
process.on('uncaughtException', (err, origin) => { console.error('El error no fue capturado') // Mensaje de Error console.error(err) // Detalle del error })
Para las promesas que no fueron resueltas y no tuvieron manejador de errores, se puede utilizar el siguiente evento.
process.on('uncaughtRejection', (err, origin) => { console.error('El error no fue capturado') console.error('err') })
todo lo que vaya en el evento process.on(‘exit’) debe ser sincrono para poder visualizarlos en el mismo hilo que está cerca de cerrarse
Modulo process
Con este modulo podremos controlar los procesos que ejecutamos con node. Process es un modulo por defecto de node y no tenemos que requerirlo.
// Se ejecuta antes que el proceso acabe process.on('beforeExit', () => { //se ejecuta primero que el exit console.log('El proceso va a terminar'); }); // Se ejecuta cuando el proceso acaba process.on('exit', () => { console.log('Manu, el proceso acabo'); });
La diferencia los dos es que exit ya se el proceso se ha desconectado del evenloop y beforeExit es que
// El setTimeout que esta dentro del process no se podrá ejecutar, en cambio el de afuera se ejecutara primero que el exit. process.on('exit', () => { console.log('Manu, el proceso acabo'); setTimeout(() => { console.log('Esto no se va a ver nunca'); },0); }); setTimeout(() => { console.log('Esto si se va a ver'); },0);
Con process podemos capturar errores que no hemos tenido en cuenta o que no prevenimos.
// Capturar excepciones que no se tuvieron en cuenta process.on('uncaughtException', (error, origen) => { console.error('Vaya se nos ha olvidado capturar un error'); setTimeout(() => { console.log('Esto viene desde las excepciones'); //Lo podemos usar cuando capturamos el error y queremos realizar una acción en otro hilo },0); }); funcionQueNoExiste(); console.log('Si el error no se recoge, esto no sale'); // Capturar promesas que se rechazaron y no se capturaron // process.on('uncaughtRejection');
El objecto process es una instancia de EventEmitter; podemos suscribirnos a el para escuchar eventos de node.
UncaughtException: Permite capturar cualquier error que no fue caputurado previamente.
exit: Se ejecuta cuando node detiene el eventloop y cierra su proceso principal.
/* - Process Asi puedes acceder a los procesos de node senales, eventos, escucharlos */ /* const process = require('process'); */ /* porcess viene en nuestros modulos globales no hace falta hacer un require para llamarlo */ /* Esto ejecuta algo justo antes de terminar el proceso de node */ process.on('beforeExit', () => { console.log('Ale, el proceso va a terminar'); }) process.on('') /* Asi enviamos codigo una vez finalice el proceso de node */ process.on('exit', () => { console.log('Ale, el proceso acabo'); /* Por lo que el proceso a finalizado ya estamos desconectados del event loop esto nofuncionaria */ setTimeout(() => { console.log('Esto no se va a ver nunca'); },0); console.log('Pero de forma sincrona si podemos seguir camellando') }); setTimeout(() => { console.log('Esto si se va a ver'); },0); /* Asi se escucha cuando no hay un tryatch o excepciones que no se an capturado */ process.on('uncaughtException', (err, origen) => { console.error('Valla se nos ha olvidado capturar un error'); console.error(err); setTimeout(() => { console.log('Esto viene desde las excepciones'); },0); }); /* Esto es una funcion no definida para que genere un error y se ejecute el uncaughtException */ funcionQueNoexiste(); console.log('Esto si el error no se recoje, no sale');
// Este evento se dispara cuando el proceso está apunto de terminar process.on('beforeExit', () => { console.log('El proceso va a terminar'); }); /* Este evento se dispara cuando el proceso ya ha terminado, Si hay un proceso asyncrono dentro del evento exit, nunca se va a ejecutar, y eso puede llegar a ser un foco de problemas */ process.on('exit', () => { console.log('El proceso ha terminado'); setTimeout(() => { console.log('Nunca voy a ejecutarme'); }, 0); }); /* Es muy util capturar una excepcion, para evitar que se pare todo el proceso */ process.on('uncaughtException', (error, origin) => { console.log('Se me olvidó capturar el error'); console.error(error.message); }); // Manejo de errores, IMPORTANTE try { hola(); } catch(error){ console.log(error.message); } console.log('Esto se ejecuta, siempre y cuando los errores esten controlados');```
// const process = require('process'); //console.log(process); process.on('beforeExit', () => { console.log('El proceso va a terminar'); }); process.on('exit', () => { console.log('El proceso acabo'); setTimeout(() => { console.log('Estno no se va a ejecutar nunca') }, 0) }); process.on('uncaughtException', (err, origen) => { console.log('Error no capturado'); setTimeout(() => { console.log('Esto viene de las exepciones') }, 0) //console.error(err); }) process.on('uncaughtRejection', () => { console.log('El proceso acabo'); }) funcionQueNoExiste(); console.log('Continua....');
¿Qué tipo de extensiones estan usando en VS Code para que te aparezcan esos atajos de process?
Hola, Giovanni :)
VSCode ya incluye por defecto algunos snippets (piezas de código frecuentes), pero puedes buscar en las extensiones e instalar las que quieras :D
Por ejemplo, la extensión JavaScript (ES6) code snippets incluye abreviaciones como imp para importar un módulo con import from, rqr para importar con require from, mde para exportar un módulo module exports, y varias otras.
VScode tiene por defecto varios shortcuts para varios lenguajes de programación.