JS Patterns Course

Davranış (Behavioral)

Observer

Bir obyektdə hadisə baş verəndə ona abunə olmuş bütün funksiyaları avtomatik xəbərdar etmək.

Orta · 16 dəqiqə · behavioral, event, pub-sub, subscription, react

Problem

Tutaq ki, istifadəçinin hər hərəkətini izləyirsən. Düymə kliki və switch toggle-ı həm log-a yazılmalı, həm də ekranda bildiriş (toast) göstərməlidir.

Ən sadə yol — hər handler-in içində hər işi bir-bir çağırmaq:

// ❌ Pis: handler hər şeyi özü bilir
const handleClick = () => {
  logEvent('User clicked button!');
  showToast('User clicked button!');
  sendAnalytics('User clicked button!');
};

const handleToggle = () => {
  logEvent('User toggled switch!');
  showToast('User toggled switch!');
  sendAnalytics('User toggled switch!');
};

Nə partlayır:

  • Təkrar. Eyni üç sətir hər handler-də kopyalanır. Sabah dördüncü iş əlavə olunanda bütün handler-ləri açıb düzəltməlisən.
  • Sıx bağlılıq (tight coupling). handleClick log sisteminin, toast kitabxanasının və analitikanın adını bilir. Onlardan birini dəyişsən, handler də dəyişir.
  • Tək məsuliyyət pozulur. Handler-in işi hadisəni qeyd etməkdir, hadisəyə reaksiya vermək yox.

Lazım olan şey: hadisəni elan edən tərəf onu kimin dinlədiyini bilməsin.

Pattern nədir

Observer — obyektin (observable) vəziyyəti dəyişəndə və ya hadisə baş verəndə ona abunə olmuş bütün obyektləri (observer) avtomatik xəbərdar edən davranış (behavioral) pattern-idir.

Analogiya: qəzet abunəsi. Redaksiya kimin abunə olduğunu adbaad tanımır — sadəcə nömrə çıxanda abunə siyahısına göndərir. Sən abunə olursan, oxumaq istəməyəndə abunəni dayandırırsan. Redaksiya sənə görə iş rejimini dəyişmir.

Struktur

İştirakçıRolu
Observable (subject)Abunə siyahısını saxlayır, hadisə baş verəndə xəbər verir
observers massiviAbunə olmuş funksiyalar və ya obyektlər
subscribe(fn)Siyahıya yeni observer əlavə edir
unsubscribe(fn)Observer-i siyahıdan çıxarır
notify(data)Bütün observer-ləri data ilə çağırır
Observer funksiyalarGələn datanı emal edir; bir-birindən xəbərsizdir
  handleClick() ---notify('User clicked button!')---> Observable
                                                          |
                                    observers = [logger, toastify]
                                                          |
                             +----------------------------+
                             |                            |
                             v                            v
                        logger(data)               toastify(data)
                     (konsola yazir)            (toast gosterir)

  Observable kimin dinlediyini bilmir - sadece siyahini gezir.

Addım-addım implementasiya

1. Sadə JavaScript versiyası

class Observable {
  constructor() {
    this.observers = [];
  }

  subscribe(func) {
    this.observers.push(func);
  }

  unsubscribe(func) {
    this.observers = this.observers.filter((observer) => observer !== func);
  }

  notify(data) {
    this.observers.forEach((observer) => observer(data));
  }
}

Niyə belə?

  • observers adi massivdir — sıra qorunur, yəni abunə olma ardıcıllığı ilə çağırılırlar.
  • unsubscribe massivi yenidən yaradır (filter), mövcud massivi dəyişmir. Bu, notify gedişatında abunə ləğv olunsa belə cari dövrün pozulmamasına kömək edir.
  • notify heç bir observer-in kim olduğunu bilmir — sadəcə funksiya kimi çağırır. Observable ilə observer arasındakı yeganə müqavilə budur.

2. İstifadəsi

const observable = new Observable();

const logger = (data) => {
  console.warn(`${Date.now()} ${data}`);
};

const toastify = (data) => {
  showToast(data);
};

observable.subscribe(logger);
observable.subscribe(toastify);

observable.notify('User clicked button!');
// 1757692800000 User clicked button!  + ekranda toast

Niyə belə?

  • logger və toastify bir-birindən tam xəbərsizdir. Biri silinsə, digəri işləyir.
  • Hadisəni elan edən kod (notify çağıran) nə log, nə toast haqqında bilir.
  • Yeni davranış əlavə etmək bir sətirdir: observable.subscribe(sendAnalytics).

Qeyd: patterns.dev-dəki orijinal nümunə toast üçün react-toastify, düymələr üçün Material UI komponentlərindən istifadə edir. Burada həmin asılılıqlar olmadığı üçün showToast şərti funksiya kimi göstərilir — məntiq eynidir.

3. Unsubscribe funksiyası qaytaran variant

class Observable {
  constructor() {
    this.observers = [];
  }

  subscribe(func) {
    this.observers.push(func);

    return () => {
      this.observers = this.observers.filter((observer) => observer !== func);
    };
  }

  notify(data) {
    [...this.observers].forEach((observer) => observer(data));
  }
}

const observable = new Observable();
const unsubscribe = observable.subscribe((data) => console.warn(data));

observable.notify('birinci');  // yazilir
unsubscribe();
observable.notify('ikinci');   // yazilmir

Niyə belə?

  • subscribe abunəni ləğv edən funksiya qaytarır — çağıran tərəf funksiyaya istinadı saxlamaq məcburiyyətindən qurtulur. React useEffect məhz bu formatı gözləyir.
  • notify içində [...this.observers] — kopya gəzilir. Əks halda observer öz içindən unsubscribe çağıranda massiv dəyişir və növbəti observer buraxıla bilər.

4. TypeScript versiyası

type Observer<TData> = (data: TData) => void;

export class Observable<TData> {
  private observers = new Set<Observer<TData>>();

  subscribe(observer: Observer<TData>): () => void {
    this.observers.add(observer);

    return () => {
      this.observers.delete(observer);
    };
  }

  notify(data: TData): void {
    this.observers.forEach((observer) => observer(data));
  }

  get size(): number {
    return this.observers.size;
  }
}

interface UserEvent {
  type: 'click' | 'toggle';
  at: number;
}

const userEvents = new Observable<UserEvent>();

userEvents.subscribe(({ type, at }) => console.warn(type, at));
userEvents.notify({ type: 'click', at: Date.now() });

Niyə belə?

  • Set eyni funksiyanın iki dəfə abunə olmasının qarşısını alır və silmə əməliyyatını massivdən sürətli edir.
  • Generic TData sayəsində observer səhv formada data alsa, build zamanı xəta verir. notify('salam') yuxarıdakı nümunədə kompilyasiya olunmur.
  • size yalnız oxunan getter-dir — xaricdən siyahıya birbaşa toxunmaq olmur.

Real nümunə

React-də observable-ı komponentə bağlamağın rəsmi yolu useSyncExternalStore hook-udur: o, xarici store-a abunə olur və dəyər dəyişəndə komponenti yenidən render edir.

// src/shared/lib/event-log-store.ts
type Listener = () => void;

export interface LogEntry {
  message: string;
  at: number;
}

let entries: LogEntry[] = [];
const listeners = new Set<Listener>();

export const eventLogStore = {
  subscribe(listener: Listener): () => void {
    listeners.add(listener);

    return () => {
      listeners.delete(listener);
    };
  },

  getSnapshot(): LogEntry[] {
    return entries;
  },

  getServerSnapshot(): LogEntry[] {
    return [];
  },

  add(message: string): void {
    entries = [...entries, { message, at: Date.now() }];
    listeners.forEach((listener) => listener());
  },
};
// src/widgets/event-log/ui/event-log.tsx
'use client';

import { useSyncExternalStore } from 'react';

import { eventLogStore } from '@/shared/lib/event-log-store';

export const EventLog = () => {
  const entries = useSyncExternalStore(
    eventLogStore.subscribe,
    eventLogStore.getSnapshot,
    eventLogStore.getServerSnapshot,
  );

  return (
    <ul>
      {entries.map((entry) => (
        <li key={entry.at}>{entry.message}</li>
      ))}
    </ul>
  );
};
// src/features/lesson-rating/ui/rating-button.tsx
'use client';

import { eventLogStore } from '@/shared/lib/event-log-store';

export const RatingButton = () => (
  <button type="button" onClick={() => eventLogStore.add('User clicked button!')}>
    Faydalı oldu
  </button>
);

Hansı hissə pattern-dir: eventLogStore observable-dır (subscribe + listener siyahısı + add içindəki notify). EventLog komponenti observer-dir. RatingButton EventLog-un varlığından xəbərsizdir — ikisi arasında birbaşa əlaqə yoxdur.

Üç detal vacibdir:

  • getSnapshot eyni istinadı qaytarmalıdır, vəziyyət dəyişməyibsə. Ona görə entries yeni massivlə əvəz olunur, mövcud massiv push ilə dəyişdirilmir — əks halda React sonsuz render dövrünə düşür.
  • getServerSnapshot server render üçündür. Next.js-də bunu vermədikdə komponent serverdə xəta verir.
  • subscribe sabit istinad olmalıdır (obyekt metodu kimi bir dəfə yaradılıb), hər render-də yenidən yaradılan funksiya abunəni hər dəfə yenidən qurar.

Nə vaxt istifadə et

  • Bir hadisəyə çoxlu və dəyişkən sayda reaksiya lazımdır: log, analitika, bildiriş, keş təmizləmə.
  • Hadisəni elan edən tərəf dinləyiciləri tanımamalıdır (separation of concerns).
  • Asinxron, hadisə əsaslı data ilə işləyirsən: WebSocket mesajları, yükləmənin bitməsi, mesaj lövhəsinə yeni mesaj gəlməsi.
  • React komponentini React-dən kənar store-a bağlayırsan (useSyncExternalStore).

Nə vaxt istifadə etmə

  • Əlaqə bir-birdir və dəyişməyəcək — adi callback və ya birbaşa funksiya çağırışı daha oxunaqlıdır.
  • Abunəçi sayı çox böyükdür və hər biri ağır iş görür — notify sinxron olduğu üçün bütün zəncir bir tick-də işləyir və interfeys donur.
  • Hadisə zəncirləri gizli olduğu üçün debug etmək çətinləşir: A hadisəsi B-ni, B isə C-ni tətikləyirsə, səbəb-nəticə əlaqəsini izləmək ağrılıdır.
  • React daxilində komponentlər arasında adi data ötürməsi lazımdırsa — props, Context və ya state menecerindən istifadə et.

Tələlər və anti-pattern-lər

1. Abunə ləğv olunmur — memory leak

Komponent ekrandan silinir, amma abunə siyahıda qalır. Observable silinmiş komponentə istinad saxladığı üçün yaddaş boşalmır və köhnə observer işləməyə davam edir.

// ❌ Pis: abunə heç vaxt ləğv olunmur
useEffect(() => {
  observable.subscribe(handleData);
}, []);
// ✅ Yaxşı: cleanup funksiyası abunəni ləğv edir
useEffect(() => observable.subscribe(handleData), []);

subscribe unsubscribe funksiyası qaytardığı üçün onu birbaşa useEffect-dən qaytarmaq kifayətdir.

2. Bir observer-in xətası qalanını dayandırır

// ❌ Pis: birinci observer xeta atirsa, ikinci hec vaxt cagirilmir
notify(data) {
  this.observers.forEach((observer) => observer(data));
}
// ✅ Yaxşı: hər observer təcrid olunur
notify(data) {
  [...this.observers].forEach((observer) => {
    try {
      observer(data);
    } catch (error) {
      console.error('Observer failed:', error);
    }
  });
}

Observable-ın işi xəbər verməkdir; observer-in daxili problemi digər abunəçilərin işini pozmamalıdır.

3. Sonsuz dövr

Observer öz içindən eyni observable-ı notify edirsə, zəncir özünü çağırır və stack dolur.

// ❌ Pis: notify -> observer -> notify -> ...
observable.subscribe((data) => {
  observable.notify(`${data} (emal olundu)`);
});
// ✅ Yaxşı: netice ayrı observable-a ötürülür
const processed = new Observable();

observable.subscribe((data) => {
  processed.notify(`${data} (emal olundu)`);
});

4. Anonim funksiya ilə abunə

// ❌ Pis: bu funksiyani sonra unsubscribe etmek mumkun deyil
observable.subscribe((data) => console.warn(data));
observable.unsubscribe((data) => console.warn(data)); // ferqli istinad — silinmir
// ✅ Yaxşı: istinadı saxla və ya unsubscribe qaytaran variantı işlət
const logData = (data) => console.warn(data);

observable.subscribe(logData);
observable.unsubscribe(logData);

İki eyni görünüşlü arrow function fərqli obyektlərdir — filter onları bərabər saymır.

Oxşar pattern-lərlə müqayisə

PatternƏsas fərqNə vaxt onu seç
Pub/Sub (event bus)Aralarında broker var, kanal adı ilə işləyir; tərəflər bir-birini heç tanımırModullar arası qlobal hadisə şini lazımdırsa
EventTarget / EventEmitterPlatformanın hazır observer implementasiyası, kanal adı + addEventListenerBrauzer və ya Node mühitində əlavə kod yazmamaq üçün
RxJS ObservableHadisə axını üzərində operatorlar: map, filter, debounceTimeMürəkkəb asinxron axınlar, ləğvetmə və backpressure lazımdırsa
Redux / ZustandObserver üzərində qurulub, amma vəziyyət mərkəzləşib və dəyişmə qaydaları sərtdirProqnozlaşdırıla bilən qlobal state üçün
CallbackBir dinləyici, birbaşa ötürülürƏlaqə bir-birdirsə və dəyişməyəcəksə

Qeyd: RxJS mənbədə case study kimi göstərilir — o, bu pattern-in üzərinə operator zəncirləri əlavə edir.

Test etmək

Observer-i test etmək rahatdır: observer sadəcə funksiyadır, ona görə saxta (mock) funksiya ötürüb neçə dəfə və hansı data ilə çağırıldığını yoxlayırsan.

// observable.test.js (Vitest)
import { beforeEach, describe, expect, it, vi } from 'vitest';

import { Observable } from './observable';

describe('Observable', () => {
  let observable;

  beforeEach(() => {
    observable = new Observable();
  });

  it('butun abunecileri eyni data ile cagirir', () => {
    const first = vi.fn();
    const second = vi.fn();

    observable.subscribe(first);
    observable.subscribe(second);
    observable.notify('salam');

    expect(first).toHaveBeenCalledWith('salam');
    expect(second).toHaveBeenCalledWith('salam');
  });

  it('unsubscribe-dan sonra cagirmir', () => {
    const observer = vi.fn();
    const unsubscribe = observable.subscribe(observer);

    unsubscribe();
    observable.notify('salam');

    expect(observer).not.toHaveBeenCalled();
  });

  it('bir observer xeta atsa da digerini cagirir', () => {
    const failing = vi.fn(() => {
      throw new Error('boom');
    });
    const working = vi.fn();

    observable.subscribe(failing);
    observable.subscribe(working);
    observable.notify('salam');

    expect(working).toHaveBeenCalledTimes(1);
  });
});

Üçüncü test yuxarıdakı try/catch-li notify versiyası ilə keçir, sadə versiya ilə düşür — yəni test tələni birbaşa sənədləşdirir.

Özünü yoxla

  1. notify içində observer siyahısının kopyası niyə gəzilir?
Cavab

Çünki observer öz içindən unsubscribe çağıra bilər. Orijinal massiv gəzilərkən dəyişsə, forEach bəzi elementləri buraxar. [...this.observers] kopyası cari dövrün bütövlüyünü qoruyur — silinən observer yalnız növbəti notify-dan etibarən çağırılmır.

  1. Bu kod niyə abunəni ləğv etmir?
observable.subscribe((data) => console.warn(data));
observable.unsubscribe((data) => console.warn(data));
Cavab

İki arrow function eyni görünsə də fərqli obyektlərdir. unsubscribe daxilindəki filter istinadı !== ilə müqayisə edir, ona görə heç bir element silinmir. Funksiyanı dəyişənə yazıb istinadı saxlamaq, ya da subscribe-ın qaytardığı unsubscribe funksiyasını işlətmək lazımdır.

  1. Observer pattern ilə Pub/Sub arasındakı əsas fərq nədir?
Cavab

Observer-də observable abunəçilərin siyahısını özü saxlayır — tərəflər arasında birbaşa əlaqə var. Pub/Sub-da aralarında broker (event bus) durur: naşir mesajı kanala göndərir, abunəçi kanaldan oxuyur, biri digərinin varlığından xəbərsizdir.

  1. useSyncExternalStore-da getSnapshot hər çağırışda yeni massiv qaytarsa nə olar?
Cavab

React qaytarılan dəyəri istinada görə müqayisə edir. Hər dəfə yeni massiv gəlirsə, React vəziyyətin daim dəyişdiyini düşünür və sonsuz render dövrünə düşür (dev-də "The result of getSnapshot should be cached" xəbərdarlığı verir). Vəziyyət dəyişməyibsə eyni istinad qaytarılmalıdır.

  1. Hansı halda Observer əvəzinə adi callback seçmək düzgündür?
Cavab

Əlaqə bir-bir olanda və dinləyicilərin sayının dəyişməsi gözlənilməyəndə. Observer infrastrukturu (siyahı, subscribe, unsubscribe, cleanup) bu halda əlavə mürəkkəblik gətirir, oxunaqlılığı isə azaldır.

Tapşırıq

src/shared/lib/notification-store.ts faylında observable bildiriş store-u yaz: subscribe unsubscribe funksiyası qaytarsın, push(message) yeni bildiriş əlavə edib bütün abunəçiləri xəbərdar etsin, dismiss(id) bildirişi silsin. Sonra onu useSyncExternalStore ilə oxuyan client komponenti qur.

Qəbul meyarları:

  • subscribe unsubscribe funksiyası qaytarır və useEffect-dən birbaşa qaytarıla bilir.
  • getSnapshot vəziyyət dəyişməyibsə eyni istinadı qaytarır.
  • getServerSnapshot var — komponent Next.js server render zamanı partlamır.
  • Bir observer xəta atsa, qalan observer-lər çağırılır.
  • Vitest ilə 3 test: notify, unsubscribe, xətanın təcrid olunması.

Xülasə

  • Observer hadisəni elan edən tərəflə ona reaksiya verən tərəfi ayırır: observable abunəçiləri adbaad tanımır.
  • Minimal implementasiya üç hissədir: observers siyahısı, subscribe / unsubscribe, notify.
  • subscribe-ın unsubscribe funksiyası qaytarması ən rahat formatdır — React useEffect birbaşa onu qəbul edir.
  • Əsas tələlər: ləğv olunmayan abunə (memory leak), bir observer-in xətasının zənciri dayandırması, sonsuz notify dövrü, anonim funksiya ilə abunə.
  • React-də xarici store-u komponentə bağlamağın düzgün yolu useSyncExternalStore-dur; getSnapshot keşlənmiş istinad qaytarmalı, getServerSnapshot isə SSR üçün olmalıdır.

Mənbələr