Pattern 03/22 · Behavioral

Observer Quan sát viên

Cho nhiều nơi đăng ký "nghe" một nguồn sự kiện; khi nguồn đổi trạng thái, nó thông báo cho tất cả mà không cần biết ai đang nghe và có bao nhiêu người.

Hành vi●●○14 phút đọc8 bướccòn gọi: Publish/Subscribe, Listener, Event Stream, Source/Sink
eventpub subreactivityvuememory leakevent emitterbehavioral

01 — Mở đầu bằng code đang hỏng

Vấn đề

Trang của bạn có CartBadge, MiniCart, một hàm track() của analytics, và một socket đồng bộ giỏ hàng giữa các tab. Cả bốn đều cần biết "vừa có người thêm hàng". Bạn viết hết vào addToCart(): gọi updateBadge(), rồi track(), rồi toast(), rồi socket.emit(). Bốn dòng. Xong trong 5 phút, ai review cũng gật.

Chuyện tiếp theo xảy ra theo đúng thứ tự tự nhiên. Tính năng "mua lại" ra đời; một dev khác viết reorder() và không gọi track. Analytics ghi thiếu 7% số đơn, không lỗi nào được ném ra, ba tuần sau mới có người hỏi vì sao tỷ lệ chuyển đổi tụt. Rồi cần toast, cần push, cần audit log: mỗi consumer mới nghĩa là sửa producer, mà producer giờ nằm ở bốn chỗ khác nhau — addToCart, reorder, applyCoupon, và một server hook.

Kiểu coupling này còn phá SSR. addToCart import useToast để báo "Đã thêm vào giỏ", và useToast chạm document. Chạy client thì bình thường. Cho tới khi import addToCart vào một server route hoặc một server/api handler: Nuxt render phía server, và bạn nhận document is not defined từ một file mà không ai nghĩ là có liên quan tới UI. Producer không những biết consumer — nó import consumer, và dependency đó lan cả vào module graph.

Phía ngược lại cũng có mùi quen không kém: component con giữ ref tới cha và gọi parent.refresh(), hoặc bạn truyền onChanged qua bốn tầng props chỉ để cháu báo cho ông. "Ai đang nghe" bị mã hoá thành cấu trúc cây của app, nên mỗi lần bạn bọc thêm một wrapper component là phải sửa chuỗi props đi kèm.

Vấn đề, nói cho đúng: số consumer không cố định và không thuộc về producer, nhưng code của producer đang giả định ngược lại. Bất kỳ thiết kế nào mà "thêm một người nghe" đòi hỏi sửa "người phát" thì sẽ hỏng theo nghĩa đen — bạn sẽ quên sửa ở một chỗ, và cái giá là dữ liệu sai trong im lặng, không phải crash.

02 — Ý tưởng, chưa động vào code

Giải pháp

Observer: subject giữ một danh sách handler. Consumer tự đăng ký khi nó sống, tự huỷ đăng ký khi nó chết. emit() chỉ làm một việc: chạy qua danh sách. Producer từ đó chỉ biết đúng một sự thật — "có thể có người nghe" — và không đổi một dòng nào khi bạn thêm consumer thứ năm.

Đó là lý do đây là pattern bạn gặp nhiều nhất khi làm web, không phải vì nó đẹp nhất mà vì nó là cơ chế mặc định của mọi thứ bạn dùng hằng ngày: DOM events, Vue 3 reactivity, Node EventEmitter, RxJS, WebSocket client, VueUse useEventBus. Học Observer phần lớn là học dùng đúng và không làm hỏng nó.

Phần thật nằm ở ba thứ mà tutorial hay bỏ qua. Unsubscribe: quên là memory leak và là bug "listener chạy hai lần sau khi hot reload". Thời điểm và thứ tự: emit giữa transaction khiến observer đọc dữ liệu chưa commit; listeners chạy theo thứ tự đăng ký, mà thứ tự đăng ký thì phụ thuộc mount order. Việc nặng trong observer: emit() chạy đồng bộ trên main thread, 8 listener × 40ms là UI đứng hình. Cộng thêm thứ tư: bus toàn cục không type, không owner, không tên-event-tập-trung chắc chắn thoái hoá thành chỗ không ai dám đụng.

03 — Làm thật, mỗi bước một fragment code

Từng bước một

1

Bản "bad smell": producer gọi thẳng từng consumer

Viết bản này trước để nhìn cho rõ chỗ nào sẽ bị sửa lần nữa. Producer biết tên consumer, biết module chứa consumer, biết cả thứ tự consumer phải chạy.

tscart.ts
import { updateBadge } from '~/composables/useBadge'   // UI
import { track } from '~/utils/analytics'              // tracking
import { toast } from '~/composables/useToast'         // UI, chạm document
import { socket } from '~/plugins/socket'              // network

export async function addToCart(sku: string, qty = 1) {
  const item = await api.cart.add(sku, qty)
  updateBadge()
  track('cart_add', { sku, qty })
  toast('Đã thêm vào giỏ')
  socket.emit('cart:sync', item)
  return item
}

// reorder.ts - 3 tháng sau, một file khác, một dev khác
export async function reorder(orderId: string) {
  const items = await api.order.items(orderId)
  for (const it of items) await api.cart.add(it.sku, it.qty)
  updateBadge()      // chỉ có badge. Quên track, quên toast, quên socket. Không ai phát hiện.
}
Bốn dependency cho một hành vi nghiệp vụ duy nhất. reorder thiếu một dòng và số liệu sai suốt ba tuần.
ChốtNếu "thêm một chỗ hiển thị" bắt bạn sửa function nghiệp vụ, thì function nghiệp vụ đang biết quá nhiều.
2

Subject tối thiểu: một Map và một vòng lặp

Toàn bộ cơ chế là 18 dòng. Viết nó ra tay một lần để không còn thấy event system là phép màu, và để thấy emit chẳng qua là một for loop — điều đó sẽ giải thích mọi cạm bẫy ở bước 5 và 6.

Dùng Map<event, Set<handler>>: Set chặn đăng ký trùng và cho delete O(1). Và hãy type hoá tên event ngay từ đầu — string tự do là khởi đầu của bus thành bãi rác.

tsemitter.ts
type Handler<T> = (payload: T) => void

export class Emitter<Events extends Record<string, unknown>> {
  private handlers = new Map<keyof Events, Set<Handler<any>>>()

  on<K extends keyof Events>(event: K, fn: Handler<Events[K]>) {
    const set = this.handlers.get(event) ?? new Set()
    set.add(fn as Handler<any>)
    this.handlers.set(event, set)
  }

  emit<K extends keyof Events>(event: K, payload: Events[K]) {
    const set = this.handlers.get(event)
    if (!set) return
    for (const fn of set) (fn as Handler<Events[K]>)(payload)   // ĐỒNG BỘ, theo thứ tự đăng ký
  }
}

type CartEvents = { 'cart:add': { sku: string, qty: number }, 'cart:clear': undefined }
const bus = new Emitter<CartEvents>()
bus.on('cart:add', ({ sku }) => console.log('badge <-', sku))
bus.emit('cart:add', { sku: 'AO-1', qty: 1 })     // badge <- AO-1
bus.emit('cart:clear', undefined)                 // không ai nghe: im lặng, không lỗi
ChốtMọi hành vi của pattern chỉ là hệ quả của một vòng for: đồng bộ, theo thứ tự, và ngắt cả loop nếu một handler ném lỗi.
3

Bắt buộc: `on()` phải trả về hàm unsubscribe

Trong một app SPA, consumer chết (component unmount, route đổi, modal đóng). Nếu API của bus chỉ có on, người đăng ký không có cách nào rút lui, và bạn sẽ phải nhớ tay tên từng handler. Hãy để on() trả về hàm huỷ: đăng ký và huỷ đi cùng nhau, trong cùng một chỗ, không cần đặt tên.

Bản hiện đại hơn cho event chuẩn DOM: AbortController. Một signal tắt được cả cụm listener, kể cả những listener bạn quên mất là mình đã gắn.

tsunsubscribe.ts
on<K extends keyof Events>(event: K, fn: Handler<Events[K]>): () => void {
  const set = this.handlers.get(event) ?? new Set()
  set.add(fn as Handler<any>)
  this.handlers.set(event, set)
  return () => { set.delete(fn as Handler<any>) }     // <- sản phẩm thật của on()
}

// Cách 1: giữ lại chính hàm được trả về
const off = bus.on('cart:add', refreshBadge)
off()

// Cách 2: AbortController - dọn một loạt, không cần nhớ reference
const ac = new AbortController()
btn.addEventListener('click', refreshBadge, { signal: ac.signal })
window.addEventListener('resize', refreshBadge, { signal: ac.signal })
ac.abort()                                            // bỏ CẢ HAI listener

// Cách 3: off theo "chủ", hữu ích khi handler là closure không tên
on('cart:add', () => refreshBadge(), { owner: 'CartBadge' })
offBy('CartBadge')                                    // don sạch khi component unmount
ChốtaddEventListener trả về void và đó là sai lầm lịch sử của DOM. Thiết kế bus của bạn thì đừng lặp lại: on không trả về off là thiết kế thiếu.
4

Gắn vào lifecycle: unmount là off

Vue không tự biết bạn đã đăng ký gì vào bus riêng. Hai dòng onMounted/onBeforeUnmount là khoảng trống nơi memory leak sống. Cách sửa ít sai nhất: không để dev nhớ — bọc đăng ký vào một composable tự dọn.

Vue 3 có sẵn khái niệm này cho reactivity của nó: effect() trả về stop function, còn watch/watchEffect tự dừng khi scope của component bị dispose (nội dung của onScopeDispose). Áp dụng đúng cơ chế đó cho bus riêng là đủ.

tsuseBusEvent.ts
import { getCurrentScope, onScopeDispose } from 'vue'

export function useBusEvent<K extends keyof CartEvents>(event: K, fn: Handler<CartEvents[K]>) {
  const off = useCartBus().on(event, fn)
  if (getCurrentScope()) onScopeDispose(off)   // setup() luôn nằm trong scope
  else console.warn('useBusEvent goi ngoai scope: khong ai off ham nay')
  return off
}

// CartBadge.vue - không còn onMounted/onBeforeUnmount lỏng chỏng
<script setup lang="ts">
useBusEvent('cart:add', refreshBadge)          // tự off khi component bị huỷ
useBusEvent('cart:clear', resetBadge)
</script>

// Điều kiện sống còn: useCartBus() phải trả về ĐÚNG MỘT instance (module scope hoặc pinia).
// Nếu mỗi component gọi useCartBus() mà được một Map khác thì không ai nghe ai, và leak không ai chịu.
ChốtĐăng ký và huỷ đăng ký phải nằm cạnh nhau trong code. Nếu chúng nằm ở hai hook cách nhau 40 dòng, sẽ có ngày bạn xoá một hook.
5

Emit sau commit, không emit giữa transaction

Observer chạy ngay lập tức, trong cùng stack. Nghĩa là nếu bạn emit trước khi ghi DB xong, observer đọc DB sẽ thấy dữ liệu chưa cập nhật — bug "email gửi cho đơn chưa tồn tại". Ngược lại, observer ném lỗi sẽ làm fail cả giao dịch chỉ vì một cái toast hỏng.

Hai quy tắc, áp dụng được ngay: (1) emit sau khi commit, (2) lỗi observer thì log, không rollback. Nghiệp vụ đã xong rồi; đừng để một analytics endpoint chết làm đơn hàng bị huỷ.

tsorder-paid.ts
// SAI: observer đọc DB luc data chua committed
async function markPaid(orderId: string) {
  bus.emit('order:paid', { orderId })        // email sender đọc db ngay bây giờ -> không thấy gì
  await db.order.markPaid(orderId)
}

// ĐÚNG: commit truoc, notify sau, loi notify khong duoc giet transaction
async function markPaid(orderId: string) {
  await db.$transaction(async tx => {
    await tx.order.update({ data: { status: 'paid' } })
    await tx.audit.create({ data: { kind: 'paid', orderId } })
  })
  for (const handler of paidHandlers) {
    try { await handler({ orderId }) }
    catch (e) { logger.error({ e, handler: handler.name }, 'order:paid observer failed') }
  }
}
Cái try/catch trong loop không phải phòng xa: một observer lỗi làm 4 observer còn lại không chạy, và loop dừng lại.
Chốtemit là một vòng for, không phải một hàng đợi. Ai đó throw giữa loop thì những người sau không bao giờ được gọi.
6

Đừng làm việc nặng đồng bộ trong observer

Vì emit() là for-loop đồng bộ, tổng thời gian của mọi observer nằm trên đường đi của cú click. Tái tính bảng giá, dựng lại danh sách 5.000 dòng, gọi report() — tất cả đều làm UI đứng hình, và profiler sẽ chỉ ra emit như một cái hố 300ms.

Observer nên đánh dấu rồi về ("có thay đổi đó"), việc nặng dồn vào một chỗ chạy sau, gộp lại bằng debounce hoặc microtask. Cũng nhớ re-entrancy: observer emit lại một event mà observer khác của event đó phát tiếp → vòng lặp vô hạn, stack overflow, rất khó đọc stack trace.

tsheavy-observer.ts
bus.on('cart:add', () => recomputeEverything())     // 40ms x 8 listener = UI đứng 320ms

// Observer chi ĐÁNH DÂU; viec nang chay MỘT lần sau khi im lặng
let queued = false
bus.on('cart:add', () => {
  if (queued) return
  queued = true
  queueMicrotask(() => { queued = false; recomputeEverything() })
})
// 20 lần thêm hàng liên tiếp -> recomputeEverything() chạy ĐÚNG 1 lần

// Re-entrancy: hai observer "gọi nhau" -> crash
bus.on('cart:add', () => bus.emit('cart:sync'))
bus.on('cart:sync', () => bus.emit('cart:add', { sku: 'AO-1', qty: 1 }))   // vô hạn
// Guard: cờ "đang phát" + depth limit, hoặc tách tên event ra hai chiều rõ ràng.
ChốtObserver là thông báo, không phải công việc. Ai cần làm nặng thì đăng ký một job, đừng làm trong lúc được gọi.
7

Nhận ra Observer ở khắp nơi: cùng pattern, khác API

Khi bạn gặp một event system mới, đừng học lại từ đầu — chỉ cần hỏi ba câu: on trả về gì để off? emit là đồng bộ hay queue? một handler lỗi thì những handler khác có chạy không?

tsecosystem.ts
// 1. DOM EventTarget: off cần ĐÚNG reference (arrow inline trong render = không bỏ được)
const onScroll = () => {}
window.addEventListener('scroll', onScroll, { passive: true })
window.removeEventListener('scroll', onScroll)      // thiếu 1 dòng = 1 leak

// 2. AbortController: unsubscribe không cần nhớ reference
const ac = new AbortController()
btn.addEventListener('click', refresh, { signal: ac.signal })
ac.abort()                                          // Node.js cũng hỗ trợ signal từ 15.4

// 3. Vue 3 reactivity: effect() trả về stop handle; watch tự dừng theo scope
const stop = effect(() => console.log(cart.value.total))
stop()                                              // không stop = effect sống mãi

// 4. RxJS: subscribe() trả về Subscription
const sub = interval(1000).subscribe(tick)
sub.unsubscribe()                                   // quên: 1 timer sống suốt vòng đời app

// 5. BroadcastChannel: observer ở TAB KHÁC, không cần server
const ch = new BroadcastChannel('cart')
ch.onmessage = () => refresh()
ch.close()                                          // quên close = channel sống đến khi reload
ChốtEventTarget, EventEmitter, effect(), Subscription — cùng một pattern. API khác nhau chỉ ở chỗ: unsubscribe là trả về, hay là tham số, hay là một cái token.
8

Chốt: khi nào Observer, khi nào gọi thẳng

Observer mua một thứ: producer không cần biết consumer. Nó trả giá bằng ba thứ: bạn không grep được "ai gọi hàm này" (phải debug runtime), không có gì đảm bảo có người đang nghe, và tên event là string mà compiler không soi được.

Gọi thẳng khi: một consumer, consumer thuộc về producer, và bạn muốn lỗi thiếu chỗ gọi bị compile phát hiện. Observer khi: consumer thuộc feature khác, số consumer tăng theo thời gian, hoặc bạn buộc producer không được import code của consumer (toast/document và SSR ở đoạn 3 là ví dụ thật).

tstyped-bus.ts
// Bus sống được nhờ: event là TYPE, payload bị siết, và leak lộ ra sớm.
type AppEvents = {
  'cart:add': { sku: string, qty: number }
  'cart:clear': undefined
  'auth:logout': { reason: 'manual' | 'expired' }
}

// Bus KHÔNG chứa state. Bus chứa state = một store không tên, không devtools.
function emit<K extends keyof AppEvents>(event: K, payload: AppEvents[K]) {
  const set = handlers.get(event)
  if (!set?.size) return
  console.debug('[bus]', event, set.size)          // cho bạn thấy ai nghe, lúc dev
  for (const fn of [...set]) fn(payload)
}

function watchLeaks(event: keyof AppEvents, set: Set<unknown>) {
  if (set.size > 10) console.warn('[bus]', event, set.size, 'listener - nghi que unsubscribe')
}
Cái warn ở 10 listener lấy cảm hứng thẳng từ MaxListenersExceededWarning của Node — leak nên lộ ra ở phút thứ 5, không phải phút thứ 500.
ChốtObserver tốt có tên event trong một type duy nhất, payload bị siết, unsubscribe là bắt buộc, và có chỗ đếm listener. Thiếu một trong bốn, nó thành bãi rác.

04 — Ai nói chuyện với ai

Cấu trúc

  • SubjectNguồn sự kiện. Giữ `Map<event, Set<handler>>`, phát `emit(event, payload)`. Không biết tên bất kỳ observer nào.
  • ObserverHandler nhận payload. Đăng ký lúc mình sống, huỷ đăng ký lúc mình chết.
  • Event / PayloadThông báo **rằng** đã xảy ra gì đó, kèm dữ liệu tối thiểu. Không phải "toàn bộ state".
  • ConcreteSubjectNơi mutation thật diễn ra (store, service, socket handler) và là chỗ quyết định *khi nào* emit — sau commit.
  • ClientNgười dùng thao tác; hoặc feature thứ ba (analytics, plugin) đến đăng ký mà producer không hề hay biết.
  Client (them hang vao gio)
      |  await api.cart.add(sku)  ->  commit xong moi emit
      v
  +---------------------------------------------------------+
  | Subject (cartBus - module scope, DUNG mot instance)     |
  |   handlers: Map<event, Set<handler>>                    |
  |   on(event, fn)  ->  off           <- bat buoc          |
  |   emit(event, payload)  ->  for (fn of [...set]) fn(p)  |
  +----|-----------|-----------|-----------|-----------|----+
       v           v           v           v           v
  +---------+ +---------+ +---------+ +---------+ +---------+
  | Badge   | | MiniCart| |analytics| | socket  | | plugin  |
  +---------+ +---------+ +---------+ +---------+ +---------+
  on() khi    OFF()!      on() khi    on() khi    on() khi
  mount       unmount     mount       mount       mount
              -> off()
              Set trong

Chieu phu thuoc:  Subject  <--  Observer   (chi mot chieu)
  Subject khong biet va khong import Observer. Them consumer = them on(),
  producer khong doi mot dong nao. That off() = memory leak.

05 — Sửa tuỳ ý, chạy ngay tại đây

Chạy thử: emitter có unsubscribe, listener tự rút giữa vòng lặp

tsdemo.ts
type Handler = (payload: string) => void

class Emitter {
  private handlers = new Map<string, Set<Handler>>()

  /** Returns the unsubscribe fn. Call it on unmount or leak. */
  on(event: string, fn: Handler): () => void {
    if (!this.handlers.has(event)) this.handlers.set(event, new Set())
    const set = this.handlers.get(event)!
    set.add(fn)
    return () => { set.delete(fn) }
  }

  emit(event: string, payload: string) {
    const set = this.handlers.get(event)
    if (!set || set.size === 0) return console.log('emit ' + event + ' -> nobody listening')
    console.log('emit ' + event + ' -> ' + set.size + ' listener(s)')
    for (const fn of [...set]) fn(payload) // copy: listener có thể tự gỡ giữa vòng lặp
  }
}

const bus = new Emitter()
const log = (who: string): Handler => p => console.log('    ' + who + ' got ' + p)

const offBadge = bus.on('cart:add', log('ui-badge'))
const offOneShot = bus.on('cart:add', () => {
  console.log('    one-shot ran, detaching itself')
  offOneShot()
})
bus.on('cart:add', log('analytics'))

bus.emit('cart:add', 'sku-42')
console.log('--- component unmounted, badge unsubscribed ---')
offBadge()
bus.emit('cart:add', 'sku-99')
bus.emit('order:paid', 'x')
console
emit cart:add -> 3 listener(s)
    ui-badge got sku-42
    one-shot ran, detaching itself
    analytics got sku-42
--- component unmounted, badge unsubscribed ---
emit cart:add -> 1 listener(s)
    analytics got sku-99
emit order:paid -> nobody listening

Cùng code này chạy được bằng Bun: bun run demo.ts. Output in ra được kiểm tự động trong quá trình build site.

06 — Thành thật về cái giá

Khi nào dùng, khi nào đừng

Dùng khi

  • Nhiều hơn một consumer cho cùng một thay đổi, và bạn đoán chắc chắn số đó sẽ còn tăng: UI badge + tracking + cache invalidation + cross-tab sync.
  • Consumer thuộc một feature không có quan hệ cha-con với producer: toast, analytics, audit log, plugin. Producer không nên import chúng (và ở Nuxt, không được phép).
  • Plugin/integration system: người thứ ba đăng ký hook mà không được sửa code lõi — đây là cách VS Code, Vite, Nuxt hooks, Vitest reporter đều hoạt động.
  • DOM/browser events, WebSocket, BroadcastChannel, postMessage — những nơi "ai đang nghe" thay đổi lúc runtime, không phải lúc build.
  • Domain event phía server: order.paid → email, hoá đơn, trừ kho. Ba consumer thuộc ba module; module viết sau không sửa module viết trước.
  • Reactivity: state đổi thì nhiều chỗ hiển thị phải cập nhật. Đây chính xác là thứ Vue/Signals làm — dùng nó thay vì tự viết.

Đừng dùng khi

  • Quên unsubscribe. Component unmount nhưng bus vẫn giữ handler, handler giữ closure component → component + data của nó không bao giờ được GC. Dấu hiệu: listener chạy hai lần sau hot reload, và memory chỉ đi lên. Node EventEmitter warn ở listener thứ 11 — đó là leak detector, đừng gọi setMaxListeners() để bịt nó.
  • Bus thành bãi rác magic string: emit("cart:add") ở một file, on("cartAdd") ở file khác, compile không phát hiện. Chữa: event nằm trong một type duy nhất, payload bị siết theo event, bus không giữ state (bus giữ state là một store không tên, không devtools).
  • Emit giữa transaction: observer đọc DB/Cache chưa commit nên thấy dữ liệu cũ; hoặc observer throw làm rollback một nghiệp vụ đã thành công. Emit sau commit, và try/catch từng observer.
  • Assume thứ tự thông báo. Observers chạy theo thứ tự đăng ký, mà thứ tự đăng ký phụ thuộc mount order — tức là phụ thuộc timing. Bất kỳ hợp đồng nào kiểu "badge phải cập nhật trước khi analytics đọc" là bug chờ.
  • Mất this khi truyền method: bus.on("x", this.fetch) → handler chạy với this === undefined. Bug chỉ nổ lúc event bay, tức là lúc production. Luôn arrow-bind hoặc bọc () => this.fetch().
  • Over-engineering: đúng một consumer, producer luôn biết consumer đó, và tập rule đứng yên? Gọi thẳng. Observer chỉ đáng khi bạn thật sự cần producer không biết consumer — cái giá là bạn không còn navigate-to-definition từ chỗ phát tới chỗ nhận.

07 — Bạn đã gặp nó rồi, chỉ là không gọi tên

Trong code thật

Node.js EventEmitter

on/once/emit/removeListener là Observer nguyên bản, chạy khắp HTTP server, stream, và child_process. Hai chi tiết đáng biết: once() là Observer tự unsubscribe, và MaxListenersExceededWarning (mặc định ở 11 listener cho một event) tồn tại đúng vì leak là lỗi phổ biến nhất của pattern này.

DOM EventTarget + AbortController

removeEventListener đòi đúng reference của handler, nên arrow function tạo mới mỗi render là không bỏ được — nguồn leak số một của frontend. addEventListener(type, fn, { signal }) (browser hiện đại và Node 15.4+) giải quyết bằng cách cho một AbortController tắt cả cụm listener.

Vue 3 reactivity: effect, watchEffect, effect scope

Bên trong Vue, mỗi ref là một Subject và mỗi effect là một Subscriber: getter đăng ký, setter thông báo. effect() trả về stop function; watch/watchEffect khai trong setup() tự unsubscribe khi scope bị dispose — đó chính là onScopeDispose, và là lý do code Vue ít leak hơn bus tự viết.

RxJS và BroadcastChannel

RxJS đóng gói Observer thành Observable + Subscription, với unsubscribe() — và tài liệu của chính nó coi quên unsubscribe là lỗi số một. BroadcastChannel đưa Observer ra ngoài tab: mỗi tab vừa publish vừa subscribe, close() là unsubscribe, không cần server.

08 — Tự tay làm

Bài tập

Viết `useCartBus()` dùng chung toàn app (module scope): event **có type**, `on()` trả về unsubscribe, emit **copy danh sách** trước khi loop, và `console.warn` khi một event có hơn 10 listener. Sau đó dùng nó trong `CartBadge.vue` sao cho **không cần viết `onBeforeUnmount`**, và kiểm chứng bằng `bus.size("cart:add")` trước/sau khi mount-unmount 3 lần.

Gợi ý, mở từng cái một:

  1. Map phải nằm ở module scope (hoặc trong một Pinia store). Mỗi component gọi useCartBus() mà nhận Map mới thì không ai nghe ai.
  2. on() return () => { set.delete(fn) }. Muốn tự off trong component: getCurrentScope() + onScopeDispose(off).
  3. Trong emit, lặp qua [...set] thay vì set — nếu không, handler tự off ngay trong loop sẽ làm nhảy mất handler kế tiếp.

Bus là một Map module-scope; on add vào Set và trả về closure delete; emit copy Set rồi loop; warn khi set.size > 10. Composable useBusEvent gắn onScopeDispose(off) nên component không cần hook lifecycle. bus.size("cart:add") phải trở về giá trị cũ sau mỗi cycle mount/unmount — đó là test chứng minh không leak.

tsbai-tap.ts
// composables/cartBus.ts — MỘT bus duy nhất cho cả app
type Handler<T> = (payload: T) => void
export type CartEvents = { 'cart:add': { sku: string, qty: number }, 'cart:clear': undefined }

const handlers = new Map<keyof CartEvents, Set<Handler<any>>>()

function on<K extends keyof CartEvents>(event: K, fn: Handler<CartEvents[K]>): () => void {
  const set = handlers.get(event) ?? new Set()
  set.add(fn as Handler<any>)
  handlers.set(event, set)
  if (set.size > 10) console.warn('[cartBus]', event, set.size, 'listener - nghi que unsubscribe')
  return () => { set.delete(fn as Handler<any>) }             // on() LUÔN đi kèm off()
}

function emit<K extends keyof CartEvents>(event: K, payload: CartEvents[K]) {
  const set = handlers.get(event)
  if (!set?.size) return
  for (const fn of [...set]) (fn as Handler<CartEvents[K]>)(payload)   // copy: off giữa loop van an toan
}

export const cartBus = { on, emit, size: (e: keyof CartEvents) => handlers.get(e)?.size ?? 0 }

// composables/useBusEvent.ts
export function useBusEvent<K extends keyof CartEvents>(event: K, fn: Handler<CartEvents[K]>) {
  const off = cartBus.on(event, fn)
  if (getCurrentScope()) onScopeDispose(off)
  return off
}

// CartBadge.vue
useBusEvent('cart:add', refreshBadge)      // tự off, không cần onBeforeUnmount

// Kiểm chứng không leak
for (let i = 0; i < 3; i++) {
  const off = cartBus.on('cart:add', () => {})
  off()
}
console.log('listener con lai:', cartBus.size('cart:add'))   // 0

09 — Đọc cặp để hiểu bản chất

Pattern liên quan

  • MediatorMediator dùng Observer bên trong (colleague phát, mediator notify) nhưng **có** state và rule, và nó sở hữu luật. Observer thuần thì chỉ chuyển thông báo, không phán quyết.
  • CommandObserver thông báo "một thing đã xảy ra" sau khi xong; Command gói "hãy làm thing này" thành object để queue, retry, undo. Observer không làm undo được, Command thì có.
  • Chain of ResponsibilityDanh sách listener trông giống chain, nhưng chain **dừng** ở handler đầu tiên chịu xử lý, còn Observer gọi **mọi** handler. Nhầm hai cái này là nguồn của bug "chỉ một observer thắng".
  • MementoSau `restore(memento)`, bạn phải emit một event để UI và cache học theo state mới — nếu không, data đúng mà màn hình vẫn sai.