EventEmitter ਕੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ?

Question

Accepted Answer

**EventEmitter** ਇੱਕ Node ਦੀ ਮੁੱਖ ਕਲਾਸ ਹੈ ਜੋ **publish/subscribe** ਪੈਟਰਨ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ: ਆਬਜੈਕਟ ਨਾਮਿਤ ਈਵੈਂਟਾਂ ਨੂੰ ਮਨਜ਼ੂਰ ਕਰਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਈਵੈਂਟਾਂ ਲਈ ਰਜਿਸਟਰ ਕੀਤੇ ਲਿਸਨਰ ਜਦੋਂ ਉਹ ਫਾਇਰ ਹੁੰਦੇ ਹਨ ਤਾਂ ਚਲਦੇ ਹਨ। Node ਦے ਬਹੁਤ ਸਾਰੇ APIs (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
```

ਇਹ ਮਿਸਟਰ ਨੂੰ ਇਸਦੇ ਲਿਸਨਰਾਂ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ — `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, un-removed listeners ਤੋਂ ਮੈਮੋਰੀ-leak ਦੇ ਜੋਖਮ, ਅਤੇ ਵਿਸ਼ੇਸ਼ crash-causing `error` ਈਵੈਂਟ ਨੂੰ ਜਾਣਨਾ Node ਦੇ APIs ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਵਰਤਣ ਅਤੇ ਸੰਭਾਲੀ ਈਵੈਂਟ-ਚਲਿਤ ਸਿਸਟਮ ਬਣਾਉਣ ਦੋਵਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।