Cad é an patrún foilsithe/foscríobhaí do stáit, agus cad iad na soghluaiseachtaí air?

Question

Accepted Answer

**Publish/subscribe (pub/sub)** is patrún teachtaireachta ina **foilsitheoirí** a thairgint imeachtaí agus **foscríobhaithe** ag freagairt dóibh, gan eolas a bheith acu ar a chéile go díreach. Tá go leor leabharlann stáit (agus córais imeachtaí) bunaithe air — **foilsíonn** stór athruithe agus **foscríobhann** comhpháirteanna dóibh.

## Stór pub/sub íosta

```js
function createStore(initial) {
  let state = initial;
  const subscribers = new Set();

return {
    getState: () => state,
    setState(next) {
      state = { ...state, ...next };
      subscribers.forEach((fn) => fn(state)); // PUBLISH: notify all subscribers
    },
    subscribe(fn) {
      subscribers.add(fn);                     // SUBSCRIBE
      return () => subscribers.delete(fn);      // return an unsubscribe function
    },
  };
}
```

Glaítear `subscribe(callback)` ag comhpháirteanna chun a bheith in iúl; tugann an stór glaoch ar gach foscríobhóir nuair a bhíonn stáit ag athrú (`setState`). Is é seo go bunúsach conas a oibríonn `store.subscribe` Redux, Zustand, agus asteoraithe imeachtaí faoin tóir.

## An buntáiste decoupling

```text
Publisher (the store) doesn't know WHO is listening.
Subscribers don't know WHO published.
→ They're decoupled, communicating only through the event/store.
```

Ligann an cúpláil lag seo do chuid nach bhfuil gaol ar a chéile den aip a fhreagairt ar an athruithe céanna gan thagairtí dhíreacha ar a chéile — solúbtha agus leorscothach.

## Na soghluaiseachtaí

```text
✓ Pros: decoupled, flexible, many-to-many communication, easy to add listeners
✗ Cons:
  - Implicit flow — hard to trace WHO reacts to an event (vs explicit calls)
  - Memory leaks — forgetting to UNSUBSCRIBE keeps dead listeners alive
  - Debugging — indirection makes "why did this run?" harder to answer
  - Ordering — subscriber execution order can be non-obvious
```

Is é an baol práinneach is mó ná **dearmad ar dhíscríobh** (m.sh. ar dhífhostú comhpháirt), a chruthaíonn leocainte cuimhne agus is féidir glaochadh a dhóigh ar chomhpháirteanna marbha.

```jsx
useEffect(() => {
  const unsub = store.subscribe(handleChange);
  return unsub; // ✅ cleanup — unsubscribe on unmount
}, []);
```

## Cad chuige a bhfuil sé tábhachtach

Is é pub/sub an **méanacism bunúsach** den chuid is mó de leabharlanna stáit agus córais imeachtaí — tuiscint a bhaint as a dhemystify conas a bhreathnaíonn stóranna ar chomhpháirteanna agus conas a oibríonn `subscribe`/`unsubscribe`.

Míníonn sé an cumhacht (cumarsáid decoupled, solúbtha) agus na práinn (sreabh sonraí intuigthe atá deacair a rianú, agus leocainte cuimhne ó dhíoscríobh gan ghlanadh).

Tuiscint a bhaint as pub/sub cabhraíonn sé leat a chúis a bhaint amach faoin imoibritheacht faoin tóir agus treisíonn sé an tábhacht a bheith i gcónaí ag glanadh foscríobhaithe.