நிலைக்கான publish/subscribe வடிவமும் அதன் சமநிலைகளும் என்ன?

Question

Accepted Answer

**Publish/subscribe (pub/sub)** என்பது ஒரு செய்தி வடிவமாகும், இதில் **வெளியீட்டாளர்கள்** நிகழ்வுகளை வெளியிடுகிறார்கள் மற்றும் **சந்தாதாரர்கள்** அவர்களுக்கு பதிலளிக்கிறார்கள், ஒருவருக்கொருவர் நேரடியாக அறியாமல். பல நிலை நூலகங்கள் (மற்றும் நிகழ்வு அமைப்புகள்) இதன் மீது கட்டப்பட்டுள்ளன — ஒரு கடை *மாற்றங்களை வெளியிடுகிறது* மற்றும் கூறுகள் *அவற்றில் சந்தா செய்கிறது*.

## குறைந்தபட்ச pub/sub கடை

```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
    },
  };
}
```

கூறுகள் `subscribe(callback)` ஐ அழைத்து அறிவிக்கப்படுவதற்கு; கடை நிலை மாறும்போது (`setState`) ஒவ்வொரு சந்தாதாரককளை அழைக்கிறது. இது本質的に Redux's `store.subscribe`, Zustand, மற்றும் event emitters எவ்வாறு வேலை செய்கிறது என்பதுவே.

## அளவைக்காணக் கொள்ளுதலின் நன்மை

```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.
```

இந்த தளர்ந்த இணைப்பு, ஒரு பயன்பாட்டின் தொடர்பில்லாத பகுதிகளை, ஒரே மாற்றங்களுக்கு எதிரொலிக்க அனுமதிக்கிறது, மூல நேரடி குறிப்புகள் இல்லாமல் — நমनీய மற்றும் நீட்டிக்கூடிய.

## சமநிலைகள்

```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
```

மிகப்பெரிய நடைமுறை ஆபத்து **சந்தா இல்லாமல் செல்வது** (எ.கா. கூறு அகற்றும்போது), இது நினைவகம் கசிய ஏற்படுகிறது மற்றும் அழைப்புகளை இறந்த கூறுகளில் தீப்பிடிக்க முடியும்.

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

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

Pub/sub என்பது **பெரும்பாலான நிலை நூலகங்கள் மற்றும் நிகழ்வு அமைப்புகளின் அடிப்படை பொறிமுறை** — இதை புரிந்துகொள்வது கடைகள் எவ்வாறு கூறுகளுக்கு அறிவிக்கிறது என்பதை தெளிவுபடுத்துகிறது மற்றும் `subscribe`/`unsubscribe` எவ்வாறு வேலை செய்கிறது.

இது சக்தி (அளவைக்காணக் கொள்ளுதல், நমனீய যোগাযோகம்) மற்றும் குறைபாடுகள் (ஒரு மறைமுக தரவு ஓட்டம் கண்ணளவு கடினமாக உள்ளது, மற்றும் சுத்தமாக்கப்படாத சந்தாகளிலிருந்து நினைவக கசிவு) இரண்டையும் விளக்குகிறது.

Pub/sub ஐ அறிந்துகொள்வது உங்களை எதிராக reactivity பற்றி பகுத்தறிவு செய்ய உதவுகிறது மற்றும் எப்போதும் சந்தாவை சுத்தமாக்குவதன் முக்கியத்துவத்தை வலுப்படுத்துகிறது.