Event Emitter in NodeJS
Tags: webdev, javascript, programming, beginners
Published: 2023-11-28 03:52:19


  
In Node.js, the `EventEmitter` class is a core module that facilitates communication between objects in a publisher-subscriber pattern. It allows for the implementation of event-driven architectures, where certain parts of the code can emit events, and other parts can listen for and respond to those events. The `EventEmitter` enables decoupling of different parts of an application, making it easier to build scalable and modular systems.

Here's a brief overview of how the `EventEmitter` works:

1.**Event Subscription:** You can create an instance of `EventEmitter` and use the `on` method to subscribe to events.
    
```js
const EventEmitter = require('events'); 
const myEmitter = new EventEmitter();  
myEmitter.on('event', () => {    
	console.log('an event occurred!'); 
});
```
    
2.**Event Emission:** You can use the `emit` method to trigger an event.
    
    `myEmitter.emit('event');`
    
3.**Passing Data with Events:** You can pass data along with events to provide context or additional information.

```js
myEmitter.on('dataEvent', (data) => {console.log('Received data:', data); });  myEmitter.emit('dataEvent', { key: 'value' });
```
    
4.**Error Events:** The `EventEmitter` also has special support for error events, allowing you to handle errors more effectively in asynchronous code.  
    
```js
myEmitter.on('error', (err) => {     console.error('Error occurred:', err); });  myEmitter.emit('error', new Error('Something went wrong'));
```
    

The `EventEmitter` is the foundation for many of the asynchronous operations in Node.js, such as handling HTTP requests, file I/O, and other events. It enables developers to create robust and scalable applications by facilitating the communication and coordination of various components and modules within a Node.js application.

### Example of combined concepts of File System, Modules and `EventEmitters`

*code in the self created module logEvent.js*
```js
const { format } = require("date-fns");
const { v4: uuid } = require("uuid");
const fs = require("fs");
const fsPromises = require("fs").promises;
const path = require("path");

const logEvents = async (message) => {
  const dateTime = `${format(new Date(), "ddMMyyyy \t HH:mm:ss")}`;
  const logItem = `${dateTime}\t${uuid()}\t${message}\n`;

  try {
    //This will create a file eventLog.txt  inside a folder name logs and write the logItem
    //first check if this directory exist or not
    if (!fs.existsSync(path.join(__dirname, "logs"))) {
      //if not exist then make the dir
      await fsPromises.mkdir(path.join(__dirname, "logs"));
    }

    await fsPromises.appendFile(
      path.join(__dirname, "logs", "eventLog.txt"),
      logItem
    );

  } catch (err) {
    console.log(err);
  }
};


module.exports = logEvents;

```

*code in the index.js*
```js
const logEvents = require("./logEvents");
//working with Events common-core module
const EventEmitter = require("events");
//This is strange syntax but it is from docs.
class MyEvent extends EventEmitter {}

//initialize the object
const myEvent = new MyEvent();
// so .on listens for the event, here it is listening for log even
myEvent.on("log", (msg) => logEvents(msg));
//simulating a 2 sec delay on event emitter here

setTimeout(() => {
  //emit the event log so we use .emit
  myEvent.emit("log", "Message : log event emitted");
}, 2000);
```

In this case the ouput will be a new folder created logs and in this folder there will be a file with name eventlog.txt and in that file there will be the message in each log as follows :
`20102023 	 15:46:12	4acb4dd9-020a-488c-9e3a-6df12630dad3	Message : log event emitted
`

References to the above source of information are from the YT videos of [Dave Gray](https://www.youtube.com/@DaveGrayTeachesCode)