Como usar emissores de eventos no Node.js

Os emissores de eventos são objetos no NodeJS que acionam eventos enviando uma mensagem para sinalizar que uma ação ocorreu.

O Node.js fornece um módulo de eventos integrado. Ele contém uma classe de emissor de eventos que permite criar e manipular eventos personalizados por meio de funções de retorno de chamada.

Aqui você aprenderá como emitir eventos, ouvir e manipular dados de eventos e lidar com erros de eventos no NodeJS.

Emitindo Eventos

O módulo de eventos é uma parte central do o ambiente do lado do servidor Node.js. Assim, você não precisa instalá-lo, mas antes de usar o EventEmitter classe, você deve importar do módulo de eventos e instanciá-lo.

Igual a:

const EventEmitter = exigir("eventos");
// Instanciando o EventEmitter
const meuEmissor = novo EventEmitter();

Você pode emitir eventos usando o EventEmitterde emitir método. O emitir método leva um nome do evento e um número arbitrário de argumentos como parâmetros.

Assim que você ligar para o emitir método, ele emite o passado nome do evento

. Em seguida, ele chama de forma síncrona cada um dos ouvintes do evento na ordem em que você os registrou, passando os argumentos fornecidos para cada um. Finalmente, ele retorna verdadeiro se o evento tivesse ouvintes e falso se não tivesse ouvintes.

Por exemplo:

meuEmissor.emit("TestEvent", "foo", "bar", 1, 2);

No bloco de código acima, você passou TestEvent Enquanto o Nome do evento, e "foo,” "bar,” 1, e 2 como os argumentos. Quando o bloco de código acima for executado, ele notificará todos os ouvintes que estiverem ouvindo o TestEvent evento. Ele chamará esses ouvintes com os argumentos fornecidos.

Ouvindo eventos

Você pode ouvir eventos emitidos usando o EventEmitterde sobre método. O sobre método leva um Nome do evento e uma função de retorno de chamada como parâmetros. Quando o evento com o Nome do evento passou para o sobre método é emitido, ele invoca sua função de retorno de chamada. Este método retorna uma referência ao EventEmitter, permitindo encadear várias chamadas.

Por exemplo:

// Primeiro Ouvinte
meuEmissor.on("TestEvent", () => {
 console.log("TestEvent emitido!!!");
}); // TestEvent Emitido!!!
// Segundo Ouvinte
meuEmissor.on("TestEvent", (...args) => {
 args = args.join(", ");
console.registro(`Evento emitido com os seguintes argumentos: ${args}`);
}); // Evento emitido com os seguintes argumentos: foo, bar, 1, 2
meuEmissor.emit("TestEvent", "foo", "bar", 1, 2);

No bloco de código acima, quando o TestEvent evento emite, os ouvintes do evento invocarão suas funções de retorno de chamada. Os ouvintes reagirão na ordem em que você os registrou, o que significa que o retorno de chamada do “primeiro ouvinte” será executado antes do segundo e assim por diante.

Você pode alterar esse comportamento usando o EventEmitterde prependListener método. Este método usa os mesmos parâmetros que o sobre método. A diferença é que esse método reage primeiro ao evento, independentemente da hora em que você o registra.

Por exemplo:

meuEmissor.on("TestEvent", () => {
 console.log("TestEvent emitido!!!");
});
myEmitter.prependListener("TestEvent", () => {
 console.log("Executa primeiro")
})
// console.log (myEmitter.listeners("TestEvent"));
meuEmissor.emit("TestEvent", "foo", "bar", 1, 2);

Quando o bloco de código acima for executado, “Executes first” será registrado primeiro no console, seguido por “TestEvent Emitted!!!” independentemente da ordem em que você os registrou por causa do prependListener método.

Se você registrar vários ouvintes com o prependListener método, eles serão executados em ordem do último ao primeiro.

Observe a disposição do emissor e dos ouvintes. Os ouvintes sempre vêm antes do emissor. Esse arranjo ocorre porque os ouvintes já devem estar ouvindo o evento antes que o emissor o emita.

Para contexto, considere o bloco de código abaixo:

meuEmissor.emit("TestEvent", "foo", "bar", 1, 2);
meuEmissor.on("TestEvent", () => {
 console.log("TestEvent emitido!!!");
}); 

Se você executar o bloco de código acima, nada acontecerá porque, no momento em que o emissor emitiu o evento, nenhum ouvinte estava ouvindo o evento.

Ouvindo eventos uma vez

Dependendo de seus requisitos, pode ser necessário manipular alguns eventos apenas uma vez no ciclo de vida de seu aplicativo. Você pode conseguir isso usando o EventEmitterde uma vez método.

Este método usa os mesmos argumentos que o sobre método e funciona de forma semelhante. A única diferença é que os ouvintes cadastrados no uma vez O método escuta o evento apenas uma vez.

Por exemplo:

meuEmissor.uma vez("Evento único", () => {
 console.log("Evento tratado uma vez");
});
meuEmissor.emit("Evento único"); // Evento tratado uma vez
meuEmissor.emit("Evento único"); // Ignorado
meuEmissor.emit("Evento único"); // Ignorado

A execução do bloco de código registrará “Evento tratado uma vez” no console apenas uma vez, independentemente da frequência com que o emissor emite o evento.

Ouvintes cadastrados no uma vez reagem ao evento na ordem em que você os registra. Você pode alterar esse comportamento usando o prependOnceListener método, que funciona como prependListener. A única diferença é que os ouvintes cadastrados no uma vez O método escuta o evento apenas uma vez.

Tratamento de erros com emissores de eventos

Você deve tomar cuidado para lidar com erros de JavaScript apropriadamente e ouvintes de eventos não são exceção. Erros não tratados deles farão com que o processo do Node.js seja encerrado e seu aplicativo falhe.

Para lidar com um evento de erro, pelo menos um dos ouvintes do evento deve ter seu Nome do evento definido como erro.

Por exemplo:

meuEmissor.on("erro", (erro) => {
console.erro(`Erro: ${erro}`);
});

Ter um ouvinte lidando com um possível erro, como no bloco de código acima, impedirá que o aplicativo falhe quando ocorrer um erro.

Por exemplo:

meuEmissor.emit("erro", novo erro("Isso é um erro"));

A execução do bloco de código acima registrará “Isto é um erro” no console porque um ouvinte está lidando com eventos de erro.

Gerenciando ouvintes de eventos

O EventEmitter A classe tem vários métodos que permitem manipular e gerenciar ouvintes de eventos. Você pode obter os ouvintes de um evento, removê-los e definir o número máximo de ouvintes para um evento.

Aqui está uma tabela contendo EventEmitter métodos com os quais você pode manipular ouvintes de evento:

Você só pode chamar esses métodos em um EventEmitter instância.

Por exemplo:

meuEmissor.removeListener("TestEvent");

O bloco de código acima remove um único ouvinte para o TestEvent evento.

A importância dos emissores de eventos

Node.js adota o paradigma de programação orientada a eventos com suporte para emissores e ouvintes de eventos. A programação orientada a eventos é uma das razões pelas quais os programas Node.js são mais rápidos e diretos do que algumas alternativas. Você pode sincronizar facilmente vários eventos, resultando em maior eficiência.