Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Process

19/31
Recursos

Aportes 50

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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

En el minuto 3:07 cuando el profesor habla sobre capturar promesas que se han rechazado, no se utiliza uncaughtRejection sino unhandleRejection

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:

  1. La ruta absoluta donde está instalado Node en tu sistema.
  2. La ruta absoluta del archivo que estamos ejecutando con Node.

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:

  1. “Patricio Manuel”
  2. “Ugarte”
  3. “27”

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.

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/

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.

  • beforeExit → Es para enviar algo antes que pare un proceso.
  • exit → Es para matar un proceso.
  • uncaughtException → Permite capturar cualquier error que no fue caputurado previamente.
  • uncaughtRejection → Permite capturar cualquier error de promesas que se han rechazado.
process.on('uncaughtException', (err, origen) => {
    console.error('Se nos ha olvidado capturar un error')
    console.error(err)
})

funNoExiste()

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


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

⚠️ Atención uncaughtException no esta diseñado para remplazar el manejo de errores que debería de tener tu aplicación y debería ser tu últmo recurso para tratar de manejar errores⚠️

Hago este aporte porque tal vez muchos tengan la misma idea y lo vi en los comentarios. uncaughtException es un mecanismo crudo para manejar errores. Sobreescribira la manera por default en que Node maneja un error que no tiene ningun catch de errores. Tratar de resumir normamlente una uncaught exception puede corromper completamete tu programa. Su uso correcto es hacer operaciones sincronas para limpiar recursos antes de apagar el proceso. No resumir el programa.

Les dejo más en la documentación oficial

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.

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.

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

Lo veo como el addEventListener de javascript vanilla, escuchas un evento y a partir de él, generas cierto tipo de código con una función en el segundo parametro

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.

Warning: Using ‘uncaughtException’ correctly

‘uncaughtException’ is a crude mechanism for exception handling intended to be used only as a last resort. The event should not be used as an equivalent to On Error Resume Next. Unhandled exceptions inherently mean that an application is in an undefined state. Attempting to resume application code without properly recovering from the exception can cause additional unforeseen and unpredictable issues.

Exceptions thrown from within the event handler will not be caught. Instead the process will exit with a non-zero exit code and the stack trace will be printed. This is to avoid infinite recursion.

Attempting to resume normally after an uncaught exception can be similar to pulling out the power cord when upgrading a computer. Nine out of ten times, nothing happens. But the tenth time, the system becomes corrupted.

The correct use of ‘uncaughtException’ is to perform synchronous cleanup of allocated resources (e.g. file descriptors, handles, etc) before shutting down the process. It is not safe to resume normal operation after ‘uncaughtException’.

To restart a crashed application in a more reliable way, whether ‘uncaughtException’ is emitted or not, an external monitor should be employed in a separate process to detect application failures and recover or restart as needed.
https://nodejs.org/dist/latest-v14.x/docs/api/process.html#process_warning_using_uncaughtexception_correctly

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

//metodo del core process

//antes de que finalice
process.on(‘beforeExit’,()=> {
console.log('el proceso va a terminar ');
});

//proceso finaliado
process.on(‘exit’,()=> {
console.log('alex, el procesó acabo ');
});

//evitar except

process.on(‘uncaughtException’, (err, origen)=>{
console.error(‘vaya se nos ha olvidado captar un error’);
console.error(err);
});

//probocar el error
//functionque();

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


Me gusta mucho como se explica cada cosa, va muy a la par con la documentación.

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

Tambien utilizo vscode pero no me aparece la lista de opciones para la funcion process.on(), alguien sabe como hacer que aparezca la lista?

process.on(‘exit’): es util cuando hay una excepción que no se ha capturado, ya que hay veces que se pasan por alto estas excepciones porque no hay try catch

process.on(‘exit’) sería como el Kill en Linux terminando con el proceso

const { set } = require("express/lib/application");

// const process = require('process');
process.on('beforeExit', () => {
  console.log('El proceso va a terminar');
});
process.on('exit', () => {
  console.log('El proceso acabo'); // todo lo que este dentro de exit es como un eventlop
  setTimeout(() => {
    console.log('Esto no se ve por que esta dentro del exit');
  }, 0);
});

setTimeout(() => {
  console.log('Esto si se ve por que esta fuera del exit');
}, 0);

process.on('uncaughtException', (err, origen) => {
  console.error('Se nos olvido capturar un error');
  setTimeout(() => {
    console.log('Esto viene desde las exepciones');
  }, 0);
}); // Capturar exepciones que no se han capturado

functionQuenoexiste();


// process.on('uncaughtRejection'); // Para promesas que se rechazaron y nadie tiene un cath

//const p = require(‘process’);

process.on(‘beforeExit’,()=>{
console.log(‘el proceso va acabar’);
});

process.on(‘exit’,()=>{
console.log(‘el proceso acabado’);
});

process.on(‘uncaughtException’,(err,origen)=>{
console.log(‘vaya se nos a olvidado capturar un eror’);
console.log(err);
});

functionexuste()

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

En esta clase aprenderemos a usar el módulo del proceso de Node. Como accederemos al proceso, escuchar señales, eventos, y poder interactuar con todo lo del proceso.

Para importar el proceso lo hacemos de la siguiente manera

const process = require("process");

Pero realmente no hace falta importarlo, ya que process es un MÓDULO GLOBAL.

Métodos y propiedades del módulo global Process.

Tiempo de terminado del proceso

Si queremos ejecutar una instrucción antes o cuando el proceso haya terminado (por completo) utilizamos los siguientes métodos del módulo del proceso.

Para acceder a las propiedades del proceso usamos usualmente process.on().

//ejecutar algo justo antes que el proceso termine
process.on("beforeExit", () => console.log("The process will ends"));
//si se puede colocar funciones asíncronas

//ejecutar algo cuando el proceso haya terminado por completo
process.on("exit", () => console.log("The process has finished"));  
// no colocar funciones asíncronas

‼ Aclaración: exit se ejecuta cuando Node detiene el Event Loop y se cierra el proceso principal, es decir que todo lo que coloquemos para ejecutar tiene que ser SÍNCRONO.

Si colocamos una función asíncrona nunca va aparecer ya que cuando se vaya a ejecutar el proceso habrá terminado.

Capturar errores en el proceso

Una forma de evitar que el proceso de Node se rompa al ocurrir un error es utilizando el siguiente método.

Esto capturará los errores que no fueron capturados previamente (try/catch) y permitirá que el proceso siga ejecutandose, pero detendrá el código que falló.

// captura cualquier error que no fue capturado previamente 
// se ejecutará lo que está dentro de la función
process.on("uncaughtException", (error, origin) => {
  console.error("Se nos ha olvidado capturar el error");
  console.error(error);
});

hello();

console.log("If the process wasn't caught this will appears");

Con este método se pueden ejecutar funciones asíncronas para que se ejecuten una vez se haya capturado el error.

  • unhandledRejection captura las promesas que fueron rechazadas

En el minuto 3:07 cuando el profesor habla sobre capturar promesas que se han rechazado, no se utiliza uncaughtRejection sino unhandleRejection

process(‘uncaughtException’): es util cuando se necesita monitorear un proceso en produccion o cuando se está haciendo un testeo intensivo

process(‘uncaughtException’): permite capturar el error que no ha sido capturado en try catch y taambien saber el origen del error

**> una excepción no captura puede destrutir el proceso principal de node
**

process.on(‘beforeExit’) : escucha antes de que termine el proceso

process.on(‘exit’) para detectar cuando el programa termina

Recuerden el módulo process es GLOBAL y no es neceasrio importarlo

con el modulo process entramos a el proceso de node que se puede acceder , esuchar señales, entender lo que pasa, eventos que dispara el proceso.

Escuchar eventos de node, excelente para monitorear

Para crear archivos de log jejeje muy interesante

Buenísima clase! Y a penas voy por la mitad

el módulo ‘process’ hace parte de los módulos globales, No es necesario requerirlos en el código.

Esta increíble todo esto 😮

Qué cool esto.

Qué buena clase!!!

muy buena clase

PROCESS = Objeto de proceso es un objeto global que proporciona información y control sobre el proceso actual de Node.js.
😃

process

uncaughtException