A Classe Event Emitter do Nodejs
Tags: node, javascript
Published: 2020-08-30 16:15:20

# A Classe Event Emitter do NodeJs

**Event Emitters** são um dos conceitos mais importantes no Node, pois é com eles que emitimos eventos, que podem ser ouvidos por outros objetos no programa. Através dessa arquitetura é que podemos **conectar** pedaços de código distantes entre sí.

## Mas afinal, o que são Event Emitters?

Um Event Emitter é um objeto que emite notificações, ou eventos, em diferentes partes do seu ciclo de vida. Por exemplo, um servidor emite eventos em cada estágio da sua inicialização até o seu desligamento. Quase todos os core modules do node fazem uso dos event emitters, que também são importantes para a implementação da programação assíncrona, conceito essencial do mundo javascript.

## A Classe Event Emitter

O objeto event emitter reside no módulo chamado 'events'. Normalmente, não usuaríamos diretamente esse módulo, mas sim de objetos que fazem uso dele.

Na classe Event Emitter temos vários métodos interessantes para emitir, cadastrar e processar eventos. Alguns dos mais usados são ***on( )***, onde registramos um event, e ***emit( )*** onde emitimos de fato o evento.

Para começar, vamos importar o módulo 'events' no nosso arquivo ***index.js***:

```javascript
const EventEmitter = require('events');
```

Depois de importar o módulo, vamos criar uma classe chamada Coração com o seguinte método:

```javascript
class Coracao extends EventEmitter {
    bater() {
        setInterval(() => {
            console.log('Tum-tum');
            this.emit('bater');
            console.log('Tum-tum');
        }, 1000)
    }
};
```
Acima criamos uma classe que simula um coração e que herda de Event Emitter (assim teremos acesso a todos os seus métodos), nela definimos um método chamado bater( ), que emite um evento com o nome de 'bater' e printa no console.

Agora, precisamos registrar um listener para sermos notificados desse evento toda vez que ele é emitido.

```javascript
const coração = new Coracao();
coração.on('bater', () => {
    console.log('Ouvindo o coração batendo');
});
```

Acima cadastramos uma função que 'ouve' o evento 'bater' emitido pelo método bater( ) da classe coração.

Agora precisamos chamar o método para que possamos processar e emitir o evento:

```javascript
coração.bater();
```
No console, temos: 

```javascript
Tum-tum
Observando o coração batendo
Tum-tum
Tum-tum
Observando o coração batendo
Tum-tum
Tum-tum
Observando o coração batendo
Tum-tum
Tum-tum
Observando o coração batendo
Tum-tum
Tum-tum
Observando o coração batendo
Tum-tum
Tum-tum
```
## Processando dados com Event Emitter

Podemos também processar dados com o Event Emitter, um exemplo simples seria somar os elementos de um array, e retornar para o listener (ou receptor) o resultado da soma:

```javascript
const sumEvent = new EventEmitter();
```
Acima instanciamos o objeto Event Emitter, que vamos chamar de sumEvent. Depois, vamos registrar um evento que será executado quando emitido. Para isso, vamos definir o nome do evento, os dados que ele irá receber e uma função de callback que será retornada passando o resultado da soma:

```javascript
sumEvent.on('sum', (numbers, callback) => {
    const result = numbers.reduce((n, sum) => sum += n);
    return callback(result);
});
```

Agora vamos emitir o evento passando os nossos parametros:

```javascript
sumEvent.emit('sum', [1, 2, 3], (result) => {
    console.log(result);
}); 
```
Quando o evento é emitido, temos: 

```javascript
6
```
E é assim que usamos a classe Event Emitter do node.