Nodejs-процесс События

Что такое модуль процесса Nodejs?

Модель процесса Node.js отличается от традиционных веб-серверов тем, что Node.js работает в одном процессе, а запросы обрабатываются в одном потоке. Одним из преимуществ этого является то, что Node.js требует гораздо меньше ресурсов. При поступлении запроса он помещается в очередь событий. Node.js использует цикл обработки событий для прослушивания событий, которые необходимо вызвать для асинхронного задания. Цикл событий работает непрерывно, получая запросы из очереди событий. Не теряя времени, давайте углубимся в модуль Process.

Модуль Process доступен глобально во время выполнения nodejs, к которому мы можем получить прямой доступ, не импортируя модуль. Если мы хотим, мы можем импортировать модуль, используя require, как показано ниже.

const process = require('process');

Модуль Process показал некоторые API, которые мы будем использовать для создания мощного приложения, мы углубимся в требуемое объяснение, и наиболее часто используемые из них давайте начнем сейчас.

Обработка событий

Модуль Process предоставляет некоторые из событий, которые имеют свою собственную ответственность, перечисленную ниже.

1. перед выходом.
2. Отключить.
3. выход.
4. сообщение.
5. несколько разрешений.
6. необработанный отказ.
7. неперехваченное исключение.
8. предупреждение.

Давайте обсудим каждый с объяснением.

1. перед выходом

Это событие генерируется, когда Node.js очищает свой цикл обработки событий и не имеет дополнительных задач для планирования. это событие можно использовать для планирования любой дополнительной работы перед уничтожением процесса. давайте небольшой пример.

const x = 10;
const y = 10;
function sum(a, b) {
return a + b;
}
console.log(`sum of ${x} and ${y} is`, sum(x, y));
process.on('beforeExit', (code) => {
console.log("process before exit event with code ", code)
})

Вывод приведенного выше кода показан ниже.

как вы видите, прослушиватель был выполнен, указанный выше прослушиватель не будет выполнен, если process.exit() вызывается или во время любого необработанного исключения, давайте попробуем это с кодом ниже.

const x = 10;
const y = 10;
function sum(a, b) {
process.exit()
return a + b;}
console.log(`sum of ${x} and ${y} is`, sum(x, y));
process.on('beforeExit', (code) => {
console.log("process before exit event with code ", code)
})

Для приведенного выше кода никакие выходные данные не будут выводиться на консоль, потому что мы вручную выходим с помощью process.exit(). Давайте вызовем исключение и попробуем с приведенным ниже кодом.

const x = 10;
const y = 10;
function sum(a, b) {
throw 1;
return a + b;
}
console.log(`sum of ${x} and ${y} is`, sum(x, y));
process.on('beforeExit', (code) => {
console.log("process before exit event with code ", code)})

приведенный выше код также не будет выполнять функцию прослушивателя.

2. отключить

событие отключения процесса поможет отключить (закрыть канал IPC) дочерний процесс, когда он больше не нужен, давайте рассмотрим пример ниже. если вы не знаете, что такое дочерний процесс, просмотрите документацию или подождите несколько дней я собирался написать статью об этом в ближайшие дни.

*Parent Process
const{fork}=require('child_process');
const child=fork('./child.js');
child.send("Hey child ,Iam parent");
child.disconnect();
*Child Process
process.on("message", (message) => {
console.log(message);
});
process.on("disconnect", (messag) => {
console.log("Parent Disconnected with me");
});
Note* Both the child process and parent process code should be in seperate js file

Вывод приведенного выше кода.

Как вы видите, прослушиватель разъединения в дочернем элементе вызывается, как только событие разъединения исходит от родителя. после отключения, если родитель попытается отправить какое-либо сообщение, которое не будет отправлено, и будет выдано исключение с сообщением канал закрыт.

3. выход

Давайте возьмем приведенный выше пример и изменим приведенный выше код для достижения этих целей.

*Parent Process
const { fork } = require('child_process');
const child = fork('child.js');
child.send("First Message from parent");
child.send("Second Message from parent");
*Child Process
process.on('message',(message)=>{
console.log(message);
process.exit();})
Note* Both the child process and parent process code should be in seperate js file

Как вы видите выше, родитель отправил два сообщения дочернему процессу, но в дочернем процессе. В дочернем процессе мы вызываем событие выхода после получения первого сообщения, поэтому следующее сообщение от родителя не будет получено от родителя. давайте прослушаем событие выхода в дочернем процессе с помощью приведенного ниже кода.

*Child Process
process.on('message',(message)=>{
console.log(message);
process.exit();})
process.on('exit',()=>{
console.log("child process exited");
})

вывод приведенного выше кода показан ниже

Как вы видите выше, после вызова Process.exit(). exitпрослушиватель был выполнен. Если внутри функции прослушивателя происходят какие-либо асинхронные вещи, они будут проигнорированы. то есть функция слушателя всегда должна быть синхронной.

4. сообщение

Я думаю, вы уже знакомы с тем, что делает событие сообщения, если вы рассмотрели все пункты выше. мы можем прослушивать события сообщений, используя приведенный ниже код.

process.on("message",(message)=>{
console.log(message);
})

5. множественные разрешения

Это полезно для отслеживания потенциальных ошибок в приложении при использовании конструктора Promise, так как несколько разрешений молча проглатываются. Однако возникновение этого события не обязательно указывает на ошибку. Например, Promise.race() может вызвать событие 'multipleResolves'.

Это событие будет запущено, когда произойдет любое из следующих событий

1. Решалась не один раз.
2. Отказали не раз.
3. Отклонено после решения.
4. Решено после отклонения.

Ниже мы пример для вышеуказанных условий

*Resolved more than once 
new Promise((resolve, reject) => {
resolve('First call');
resolve('Swallowed resolve');
});
*Rejected more than once.
new Promise((resolve, reject) => {
reject('First call');
reject('Swallowed reject');
});
*Rejected after Resolve
new Promise((resolve, reject) => {
resolve('First call');
reject('Swallowed reject');
});
*Resolved after Reject
new Promise((resolve, reject) => {
reject('Swallowed reject');
resolve('First call');
});

Потенциальную ошибку такого типа можно зафиксировать с помощью события multipleResolves, используя приведенный ниже код.

process.on('multipleResolves', (type, promise, reason) => {
console.error(type, promise, reason);
});

6. необработанный отказ

Скажем, у вас есть большой проект, запущенный заранее, и вы забыли обработать отклонение обещания, и это может привести к потенциальной ошибке внутри приложения, и теперь вам нужно отслеживать необработанный отказ, и вам нужно знать, что пошло не так. вы можете справиться с этим сценарием с помощью unHandledRejection, как показано в приведенном ниже коде.

new Promise((resolve,reject)=>{
reject("something went wrong")
})
process.on('unhandledRejection',(err)=>{
console.log("Rejection unHandled",err);})

7. неперехваченное исключение

В некоторых случаях мы не будем обрабатывать исключения и доверяем нашему коду, но когда код попадет в производство, могут быть шансы исключения для этого конкретного блока кода, и иногда наше приложение перестанет работать из-за этих ошибок. мы можем обрабатывать эти типы потенциальных ошибок, используя событие uncaughtException, запустив приведенный ниже код.

process.on('uncaughtException', (err) => {
console.log("Exception unHandled", err);
})
function fun() {
throw "Something went wrong"}
fun();

8. предупреждение

Предупреждение о процессе похоже на ошибку в том смысле, что оно описывает исключительные условия, на которые обращает внимание пользователь. Однако предупреждения не являются частью обычного потока обработки ошибок Node.js и JavaScript. Node.js может выдавать предупреждения всякий раз, когда обнаруживает неправильные методы кодирования, которые могут привести к неоптимальной производительности приложения, ошибкам или уязвимостям безопасности.

process.on('warning', (warning) => {
  console.warn(warning.name);    
  console.warn(warning.message); 
  console.warn(warning.stack);  
});