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).
handleClicklog 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 massivi | Abunə 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 funksiyalar | Gə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ə?
observersadi massivdir — sıra qorunur, yəni abunə olma ardıcıllığı ilə çağırılırlar.unsubscribemassivi yenidən yaradır (filter), mövcud massivi dəyişmir. Bu,notifygedişatında abunə ləğv olunsa belə cari dövrün pozulmamasına kömək edir.notifyheç 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ə?
loggervətoastifybir-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ə?
subscribeabunəni ləğv edən funksiya qaytarır — çağıran tərəf funksiyaya istinadı saxlamaq məcburiyyətindən qurtulur. ReactuseEffectməhz bu formatı gözləyir.notifyiçində[...this.observers]— kopya gəzilir. Əks halda observer öz içindənunsubscribeç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ə?
Seteyni 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
TDatasayəsində observer səhv formada data alsa, build zamanı xəta verir.notify('salam')yuxarıdakı nümunədə kompilyasiya olunmur. sizeyalnı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:
getSnapshoteyni istinadı qaytarmalıdır, vəziyyət dəyişməyibsə. Ona görəentriesyeni massivlə əvəz olunur, mövcud massivpushilə dəyişdirilmir — əks halda React sonsuz render dövrünə düşür.getServerSnapshotserver render üçündür. Next.js-də bunu vermədikdə komponent serverdə xəta verir.subscribesabit 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 —
notifysinxron 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ərq | Nə 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ır | Modullar arası qlobal hadisə şini lazımdırsa |
EventTarget / EventEmitter | Platformanın hazır observer implementasiyası, kanal adı + addEventListener | Brauzer və ya Node mühitində əlavə kod yazmamaq üçün |
RxJS Observable | Hadisə axını üzərində operatorlar: map, filter, debounceTime | Mürəkkəb asinxron axınlar, ləğvetmə və backpressure lazımdırsa |
| Redux / Zustand | Observer üzərində qurulub, amma vəziyyət mərkəzləşib və dəyişmə qaydaları sərtdir | Proqnozlaşdırıla bilən qlobal state üçün |
| Callback | Bir 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
notifyiç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.
- 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.
- 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.
useSyncExternalStore-dagetSnapshothə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.
- 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ı:
-
subscribeunsubscribe funksiyası qaytarır vəuseEffect-dən birbaşa qaytarıla bilir. -
getSnapshotvəziyyət dəyişməyibsə eyni istinadı qaytarır. -
getServerSnapshotvar — 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:
observerssiyahısı,subscribe/unsubscribe,notify. subscribe-ın unsubscribe funksiyası qaytarması ən rahat formatdır — ReactuseEffectbirbaş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;getSnapshotkeşlənmiş istinad qaytarmalı,getServerSnapshotisə SSR üçün olmalıdır.