EventEmitter என்றால் என்ன மற்றும் அதை எவ்வாறு பயன்படுத்துவது?

Question

Accepted Answer

**EventEmitter** என்பது Node-ன் முறையான வகுப்பு ஆகும், இது **publish/subscribe** வடிவத்தை செயல்படுத்துகிறது: பொருட்கள் பெயரிடப்பட்ட நிகழ்வுகளை வெளியிடுகின்றன, மற்றும் அந்த நிகழ்வுகளுக்கு பதிவு செய்யப்பட்ட கேட்பவர்கள் அவை தூண்டப்பட்டபோது இயங்குகின்றன. Node-ன் சொந்த API-ன் பெரும்பாலான பகுதி (streams, HTTP servers, process) அதன் மீது கட்டப்பட்டுள்ளது.

## அடிப்படை பயன்பாடு

```js
import { EventEmitter } from "events";

const emitter = new EventEmitter();

// SUBSCRIBE: register a listener for an event
emitter.on("order", (order) => {
  console.log(`Processing order ${order.id}`);
});

// PUBLISH: emit the event (with optional data)
emitter.emit("order", { id: 123 }); // → "Processing order 123"
```

வடிவம்: `on(event, listener)` பதிவு செய்கிறது; `emit(event, ...args)` அந்த நிகழ்வுக்கான அனைத்து கேட்பவர்களையும் ஒத்திசைப்பாக தூண்டுகிறது, வாதங்களை கடந்துசெல்கிறது.

## உங்கள் சொந்த வகுப்புகளுக்கு EventEmitter-ஐ விரிவுபடுத்துதல்

```js
class OrderService extends EventEmitter {
  placeOrder(order) {
    // ...save the order...
    this.emit("order:created", order);  // notify anyone interested
  }
}

const service = new OrderService();
service.on("order:created", (o) => sendEmail(o));   // decoupled listeners
service.on("order:created", (o) => updateAnalytics(o));
service.placeOrder({ id: 1 }); // both listeners run
```

இது emitter-ஐ அதன் கேட்பவர்களிலிருந்து பிரிக்கிறது — `OrderService` யார் கேட்கிறார்கள் என்பது அறிந்திருக்கவோ அல்லது கவலைப்பட்டிருக்கவோ இல்லை, எனவே நீங்கள் அதை மாற்றியமைக்காமலேயே எதிர்வினைகளைச் (மின்னஞ்சல், பகுப்பாய்வு, பதிவுசெய்தல்) சேர்க்கலாம்.

## பயனுள்ள முறைகள்

```js
emitter.once("ready", fn);          // listener runs only ONCE, then auto-removes
emitter.off("order", fn);           // remove a listener (prevent leaks)
emitter.emit("error", new Error()); // "error" is special — throws if no listener!
emitter.listenerCount("order");
```

## இரண்டு முக்கியமான கவனிக்க வேண்டிய விஷயங்கள்

```text
⚠️ Memory leaks: forgetting to remove listeners (use off/once). Node warns at >10
   listeners on one event ("possible EventEmitter memory leak").
⚠️ The "error" event: if emitted with no listener, Node THROWS and may crash —
   always attach an error listener to emitters that can error (streams!).
```

## Node-ல் அது எங்கே பயன்படுத்தப்படுகிறது

```text
streams (data, end, error events), http.Server (request event),
process (SIGTERM, exit), sockets — all are EventEmitters.
```

## இது ஏன் முக்கியமானது

EventEmitter என்பது Node-ன் நிகழ்வு-চালিত கட்டமைப்பின் ভিত்தி — streams, servers, மற்றும் process பொருள் எவ்வாறு செயல்படுகிறது என்பதை புரிந்துகொள்வது (அவை அனைத்தும் emitters), மற்றும் இது உங்கள் சொந்த குறியீட்டில் பிரிக்கப்பட்ட, நிகழ்வு-அடிப்படையிலான संचारனுக்கான நிலையான கருவி.

`on`/`emit`/`once`/`off` API, நீக்கப்படாத கேட்பவர்களிலிருந்து நினைவகக் கசிவு ஆபத்து, மற்றும் வினாசகர மூல `error` நிகழ்வு பற்றிய அறிவு Node-ன் API-களை சரியாகப் பயன்படுத்துவதற்கும் பராமரிக்கக்கூடிய நிகழ்வு-சார்ந்த அமைப்புகளைக் கட்டுவதற்கும் அவசியமாகும்.