Pattern 06/22 · Structural

Decorator Trang trí

Bọc một object trong một object khác có đúng cùng interface để thêm trách nhiệm (log, retry, cache, validate) xung quanh lời gọi — client không biết và không cần biết nó đang cầm bản đã bọc.

Cấu trúc●●○15 phút đọc8 bướccòn gọi: Wrapper; KHÔNG đồng nhất với cú pháp @decorator của TypeScript
structuralwrappermiddlewareHOCcompositioncross-cutting

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

Vấn đề

StripeGateway.pay() của bạn dài 12 dòng và chạy tốt. Rồi requirement đầu tiên tới: "log lại mọi giao dịch". Bạn thêm console.log vào đầu và cuối hàm. Requirement thứ hai: "gặp 5xx thì retry 3 lần với backoff". Bạn bọc phần gọi HTTP trong một vòng for. Thứ ba: "đừng gửi hai lần cho cùng một idempotency key". Bạn thêm một Map nhớ kết quả. Thứ tư: circuit breaker. Thứ năm: metric pay_duration_ms.

Bây giờ pay() dài 140 dòng. Nó không còn chứa logic thanh toán — nó chứa logic thanh toán cộng với năm thứ không liên quan tới thanh toán, và bạn không thể tắt cái nào mà không sửa nó. Test "luồng pay có đúng không" giờ bắt buộc phải đi qua logger và hàng tồn của cache, hoặc bạn mock ba thứ.

Rồi product muốn tổ hợp khác nhau theo nơi dùng: API refund thì không retry, API payment thì retry 3 lần, job offline thì retry 10 lần và log sampled. Hàm của bạn biến dạng thành pay(amount, opts: { retry?: boolean, log?: boolean, cache?: boolean, dryRun?: boolean }), bên trong là if (opts.retry && !opts.dryRun). Bốn cờ là 16 hành vi, bạn chỉ chắc đúng 2 trong số đó, và cái if lồng thứ năm sẽ tới.

Có người đề nghị kế thừa: LoggedStripe, rồi RetryLoggedStripe extends LoggedStripe, rồi CachedRetryLoggedStripe. Bạn vừa đẩy ma trận tổ hợp vào tên class, và tệ hơn: logic retry nằm trong một subclass của Stripe, nên ngày SMS gateway cần đúng retry đó, bạn phải copy 40 dòng hoặc sửa lại cả cây kế thừa.

Chuyện này không đặc thù payment. Trong Vue/React nó là: một component bị bọc withAuth, rồi bị bọc thêm withTrack, rồi bị bọc withI18n, mỗi cái một người viết, không cái nào biết ba cái kia tồn tại; là bốn file useFetchWithRetry copy-paste nhau vì chưa ai chịu tách "retry" thành một thứ độc lập. Cái hỏng khi dự án lớn lên rất cụ thể: hành vi cross-cutting bị phết khắp code nghiệp vụ, nên không tắt được, không test riêng được, và policy của endpoint này rò sang endpoint khác.

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

Giải pháp

Decorator: viết một object cùng interface với thứ nó bọc, nhận object đó lúc tạo (constructor(private inner: PaymentGateway)), và thêm việc của mình quanh lời gọi tới inner — trước, sau, hoặc lặp lại lời gọi. StripeGateway không đổi một dòng.

Vì wrapper cũng là PaymentGateway, nó bọc được cả wrapper khác: new WithLog(new WithRetry(new WithCache(gateway))). Client giữ interface, không phân biệt được bên trong có bao nhiêu tầng. Toàn bộ "chính sách" (log ở đâu, retry mấy lần, tầng nào nằm ngoài) trở thành code cấu hình ở một chỗ, xoá sạch cây if (opts.retry).

Trong JS/TS, hình dạng phổ biến nhất không phải class mà là function nhận function, trả về function cùng shape: withRetry(send) cho ra một send mới. React gọi nó là HOC (React.memo, withTranslation), Express gọi nó là plugin, Nitro gọi nó là defineCachedEventHandler, Zustand gọi nó là middleware. Cùng một pattern, bốn cái tên. Một cảnh báo trước kẻo nhầm: cú pháp @decorator của TypeScript không phải pattern Decorator — nó là hook lúc định nghĩa class, khác hẳn ý đồ và thời điểm chạy (Bước 6).

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

Từng bước một

1

Gọi interface, đừng gọi class

Đây là hiện trạng: pay() còn sạch, nhưng ba dòng XXX dưới đây là ba món nợ sẽ tới hạn — mỗi lần product đòi thêm log, retry, cache, metric, ta lại phải mở chính hàm nghiệp vụ này ra sửa.

Điều kiện tiên quyết: client phải gọi qua một interface (hoặc một function type), không gọi new StripeGateway() ở khắp nơi. Không có cái này thì không có gì để bọc — wrapper không có chỗ đứng.

tscomponent.ts
export interface PaymentGateway {
  pay(amount: number): string
}

/** ConcreteComponent: chỗ DUY NHẤT chạm SDK của vendor. */
export class StripeGateway implements PaymentGateway {
  pay(amount: number): string {
    // XXX: client import thẳng class này -> không còn chỗ nào để chèn wrapper
    // XXX: "thêm log cho endpoint này" = sửa đúng hàm nghiệp vụ này
    // XXX: thêm log + retry + cache + metric thì 12 dòng này phình thành 140 dòng
    return 'stripe: OK ' + amount + 'đ'
  }
}

// checkout.ts, refund.ts, cron-retry.ts — mỗi nơi một kiểu:
// const gateway = new StripeGateway()          // không retry, không log
// const gateway = new StripeGateway(true)      // bản "có retry" ai đó thêm sau
Toàn bộ quyền lực của Decorator nằm ở một dòng: client gọi PaymentGateway, không gọi StripeGateway.
ChốtDecorator cần một interface chung để đứng lên. Nếu client đang import thẳng class cụ thể, refactor đó là bước 0 (và thường là Adapter/Dependency Injection).
2

Decorator đầu tiên: logging, component không đổi một dòng

Wrapper chỉ làm ba việc: nhận inner, gọi inner, thêm gì đó quanh lời gọi. Nó không biết bên trong là Stripe hay Portal, và không cần biết.

tswith-log.ts
import type { PaymentGateway } from './component'
import { StripeGateway } from './component'

/** ConcreteDecorator: cùng interface, thêm một trách nhiệm. */
export class WithLog implements PaymentGateway {
  constructor(private inner: PaymentGateway, private tag: string) {}

  pay(amount: number): string {
    const out = this.inner.pay(amount)
    console.log('[' + this.tag + '] ' + out)
    return out
  }
}

const gateway: PaymentGateway = new WithLog(new StripeGateway(), 'audit')
gateway.pay(150_000)
gateway.pay(20_000)
console
[audit] stripe: OK 150000đ
[audit] stripe: OK 20000đ
StripeGateway không có một dòng logging nào. Xoá WithLog đi, mọi thứ còn chạy nguyên.
ChốtMột decorator chỉ thêm một trách nhiệm. Nếu decorator của bạn vừa log vừa retry, bạn đã quay lại chỗ cũ với hai lớp thay vì một.
3

Xếp chồng: thứ tự các tầng là chính sách

Vì mỗi tầng đều là PaymentGateway, bạn xếp chúng theo thứ tự nào cũng được — và thứ tự đổi hành vi. WithLog(WithRetry(gateway)) log một lần cho kết quả cuối; WithRetry(WithLog(gateway)) log mỗi lần thử vì log nằm trong vòng retry.

Muốn metric đo cả thời gian retry? Đặt WithMetric ngoài WithRetry. Muốn log chỉ dành cho khách hàng (không lộ 503)? Đặt WithLog ngoài cùng. Muốn log debug nội bộ từng attempt? Đặt nó trong cùng. Đây là loại quyết định mà cây if (opts.log) không bao giờ diễn đạt nổi rõ ràng.

tsstack.ts
const choKhach: PaymentGateway =
  new WithLog(new WithRetry(new WithMetric(new StripeGateway()), 3), 'audit')

const choDebug: PaymentGateway =
  new WithRetry(new WithLog(new StripeGateway(), 'attempt'), 3)

// Client của cả hai: giống hệt nhau.
const result = choKhach.pay(150_000)
Stack là code, và code thì review được: reviewer đọc 2 dòng này biết ngay hệ thống log gì, retry gì.
ChốtDecorator biến "chính sách vận hành" thành một biểu thức dựng object — đổi chính sách là đổi cách dựng, không đổi logic.
4

Bản JS thật: decorator là function nhận function

Nếu component của bạn đã là một function (gọi API, send mail, đọc DB), thì decorator tự nhiên nhất là higher-order function cùng shape — không class, không interface file:

tshof.ts
type Pay = (amount: number) => string

const withLog = (inner: Pay, tag: string): Pay =>
  (amount) => {
    const out = inner(amount)
    console.log('[' + tag + '] ' + out)
    return out
  }

const withRetry = (inner: Pay, max: number): Pay =>
  (amount) => {
    let out = ''
    for (let i = 0; i < max; i++) {
      out = inner(amount)
      if (!out.includes('503')) break
    }
    return out
  }

const pay: Pay = withLog(withRetry(rawStripePay, 3), 'audit')
Cùng pattern, ít ceremony hơn. Closure giữ "inner" thay vì constructor field.
ChốtClass Decorator khi cần trạng thái/nhiều method và instanceof còn có nghĩa; function Decorator khi mọi thứ là một lời gọi. Đừng ép xác GoF vào code JS.
5

Decorator quanh I/O: timeout, retry, cache — theo đúng nghĩa đen

Ba decorator quanh một fetch-like function, viết theo hình mà bạn sẽ thật sự viết trong server/api/. Chú ý mỗi tầng tự đóng chính sách của nó và không truyền chính sách xuống tầng khác.

tshttp-decorators.ts
type Fetcher = (url: string) => string

/** Timeout: bọc bằng AbortController, thêm lỗi có tên. */
const withTimeout = (inner: Fetcher, ms: number): Fetcher =>
  (url) => {
    const ac = new AbortController()
    const timer = setTimeout(() => ac.abort(), ms)
    try {
      return inner(url) // signal: ac.abort.signal khi dùng fetch thật
    }
    finally {
      clearTimeout(timer)
    }
  }

/** Cache: biến một hàm thành hàm có nhớ, key = url. */
const withCache = (inner: Fetcher, ttlMs: number): Fetcher => {
  const memo = new Map<string, { at: number, value: string }>()
  return (url) => {
    const hit = memo.get(url)
    if (hit && hit.at + ttlMs > Date.now()) return hit.value
    const value = inner(url)
    memo.set(url, { at: Date.now(), value })
    return value
  }
}

// với fetch thật: inner cần nhận signal -> dùng type Fetcher = (url, signal) => Promise<Response>
withTimeout, withRetry, withCache viết một lần, dùng cho mọi endpoint. Đây là phần "đáng tiền" của pattern.
ChốtDecorator là cách duy nhất thêm timeout/cache/retry vào một hàm mà không được phép sửa hàm đó (SDK vendor, code của team khác).
6

`@decorator` của TypeScript là chuyện khác, đừng nhầm

TypeScript 5 hỗ trợ decorator chuẩn ECMAScript (stage 3) — cú pháp @ đặt trên class member. Nó là hook lúc định nghĩa class: nhận method gốc + context, trả về method đã thay. Nó không tạo object mới, không xếp lớp quanh một instance, và client không chọn được "có decorator này, không có decorator kia" lúc chạy.

tsts-decorator.ts
// Cú pháp @: biến đổi method lúc ĐỊNH NGHĨA class (metadata hook).
function timed<This, Args extends unknown[], R>(
  method: (this: This, ...args: Args) => R,
  ctx: ClassMethodDecoratorContext,
) {
  return function (this: This, ...args: Args): R {
    const t0 = performance.now()
    const out = method.apply(this, args)
    console.log(String(ctx.name) + ' hết ' + Math.round(performance.now() - t0) + 'ms')
    return out
  }
}

class Gateway {
  @timed
  pay(amount: number) { return 'OK ' + amount + 'đ' }
}
Trông giống "thêm hành vi quanh một method", nên trùng tên. Nhưng nó chạy một lần khi class được định nghĩa, áp cho mọi instance, và không compose thành stack có thứ tự.
ChốtDecorator pattern = object runtime bọc object, chọn được, đổi thứ tự được. @decorator = cú pháp patch class member. Bạn có thể dùng cú pháp @ để viết một decorator, nhưng hai khái niệm không phải một.
7

Ba thứ decorator phá hỏng: instanceof, `this`, side effect

gateway instanceof StripeGateway là false — wrapper không phải Stripe. Nếu code nào đó đang dựa vào instanceof để đối xử đặc biệt, decorator của bạn đã làm nó hỏng một cách im lặng. Muốn mở thì expose readonly inner hoặc một hàm unwrap(); muốn đóng thì cấm instanceof với type interface.

Trích method ra khỏi object sẽ mất this (const pay = gateway.pay; pay(100)), với decorator function thì this là wrapper chứ không phải component. Bắt buộc dùng arrow hoặc bind. Và mỗi tầng retry gọi lại side effect: nếu API chưa idempotent, retry của bạn là charge tiền hai lần — đó là lý do WithRetry chỉ được đứng trước những API có idempotency key.

tsidentity.ts
const gateway: PaymentGateway = new WithLog(new WithRetry(new StripeGateway(), 3), 'audit')

// 1) danh tính: wrapper không phải component
console.log(gateway instanceof StripeGateway) // false
console.log(gateway instanceof WithLog)       // true — nhưng chẳng ai muốn dựa vào đó

// 2) this: trích method ra khỏi object là mất this
const pay = gateway.pay
// pay(150_000)                      // -> this === undefined, crash
const payBound = gateway.pay.bind(gateway)   // hoặc khai báo method bằng arrow
console.log(payBound(150_000))

// 3) số lần gọi: retry nhân side effect
class WithIdempotentRetry implements PaymentGateway {
  constructor(readonly inner: PaymentGateway, private max: number) {}
  pay(a: number) {
    // API PHẢI nhận idempotency key, nếu không 3 lần thử = 3 lần trừ tiền
    return this.inner.pay(a)
  }
}
ChốtDecorator trong suốt với giao diện, không trong suốt với danh tính và số lần gọi. Kiểm tra instanceof và idempotency trước khi xếp tầng.
8

Vue/Nuxt: composable và middleware cũng là decorator — và khi nào dừng

Trong hệ Vue, hình "nhận một thứ cùng loại, trả về thứ cùng loại đã được thêm hành vi" xuất hiện khắp nơi: React.memo(C) / withTranslation(C) là decorator của component; defineAsyncComponent, withDefaults là decorator của component/composable; Nitro có defineCachedEventHandler(handler) bọc event handler bằng cache; Zustand có persist, devtools bọc state creator. Trong Nuxt, viết withAuth(handler) trả về middleware mới là decorator.

Dừng ở đâu: 2–3 tầng là bình thường, 6 tầng là bạn đã tự viết một middleware framework và cần tài liệu. Thêm decorator khi hành vi tái sử dụng được ở ≥ 2 chỗ và tắt/bật được là một quyết định thật. Một lần duy nhất, không ai tắt? Viết thẳng vào trong function — Decorator không phải nghĩa vụ.

tsnitro-middleware.ts
// server/api/rates.get.ts — Nitro bọc handler bằng cache, handler không đổi.
export default defineCachedEventHandler(async (event) => {
  return await $fetch('https://api.example.com/rates')
}, { maxAge: 60 })

// Một decorator tay viết cho route middleware của Nuxt:
export const withAuth = (handler: (to: any) => any) =>
  (to: any) => {
    if (!useCookie('session').value) return navigateTo('/login')
    return handler(to)
  }
Đọc hai đoạn này, người ngoài thấy ngay: handler này được cache, middleware này cần login. Không có cờ, không có if.
ChốtBạn đã viết decorator suốt — nhận X, trả về X-cải-thiện. Gọi đúng tên chỉ giúp cả team biết 3 tầng stack kia nghĩa là gì.

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

Cấu trúc

  • ComponentInterface chung: `pay(amount): string`. Client chỉ biết mỗi cái này.
  • ConcreteComponent`StripeGateway` — thứ thật sự làm việc, không biết gì về logging/retry.
  • DecoratorVai trò giữ một tham chiếu `inner: Component`. Bản TS thường không cần class cha cho vai này.
  • ConcreteDecoratorMột trách nhiệm: `WithLog`, `WithRetry`, `WithCache`. Gọi inner trước/sau/lặp lại.
  • ClientNhận `PaymentGateway` đã được ghép hoàn chỉnh; không biết (không cần biết) có bao nhiêu tầng.
   Client ─── gateway.pay(150000)     (chỉ biết PaymentGateway)
                       │
                       ▼
     ┌────────────────────────────────────────┐
     │ ConcreteDecorator: WithLog             │  thêm log SAU lời gọi
     │   - inner: PaymentGateway              │
     └───────────────────┬────────────────────┘
                         ▼   (mọi hộp đều là PaymentGateway)
     ┌────────────────────────────────────────┐
     │ ConcreteDecorator: WithRetry           │  LẶP LẠI lời gọi, tối đa 3
     │   - inner: PaymentGateway              │
     └───────────────────┬────────────────────┘
                         ▼
     ┌────────────────────────────────────────┐
     │ ConcreteComponent: StripeGateway       │  chỗ duy nhất gọi HTTP
     └────────────────────────────────────────┘

  Đổi thứ tự 2 tầng trên = đổi số dòng log. Xoá 1 tầng = 1 dòng sửa.
  Thêm tầng = 1 file mới. StripeGateway và Client: 0 dòng sửa.

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

Chạy thử: cùng hai decorator, hai thứ tự, hai hành vi

tsdemo.ts
interface PaymentGateway {
  pay(amount: number): string
}

/** Component: thứ thật sự gọi cổng thanh toán (cố tình 503 2 lần đầu). */
class Stripe implements PaymentGateway {
  private tries = 0
  pay(amount: number): string {
    this.tries++
    if (this.tries < 3) return 'stripe: 503 (lần ' + this.tries + ')'
    return 'stripe: OK ' + amount + 'đ'
  }
}

/** Decorator: cùng interface, thêm trách nhiệm retry. */
class WithRetry implements PaymentGateway {
  constructor(private inner: PaymentGateway, private max: number) {}
  pay(amount: number): string {
    let out = ''
    for (let i = 0; i < this.max; i++) {
      out = this.inner.pay(amount)
      if (!out.includes('503')) break
    }
    return out
  }
}

/** Decorator: logging. Cũng là PaymentGateway nên nhét được ở bất kỳ tầng nào. */
class WithLog implements PaymentGateway {
  constructor(private inner: PaymentGateway, private tag: string) {}
  pay(amount: number): string {
    const out = this.inner.pay(amount)
    console.log('[' + this.tag + '] ' + out)
    return out
  }
}

const a: PaymentGateway = new WithLog(new WithRetry(new Stripe(), 3), 'client')
const b: PaymentGateway = new WithRetry(new WithLog(new Stripe(), 'try'), 3)

console.log('A) WithLog bọc ngoài: khách chỉ thấy 1 dòng log')
a.pay(150_000)
console.log('B) WithLog bọc trong: lần nào cũng log')
b.pay(150_000)
console
A) WithLog bọc ngoài: khách chỉ thấy 1 dòng log
[client] stripe: OK 150000đ
B) WithLog bọc trong: lần nào cũng log
[try] stripe: 503 (lần 1)
[try] stripe: 503 (lần 2)
[try] stripe: OK 150000đ

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

  • Có một trách nhiệm chéo (cross-cutting) áp cho nhiều nơi: logging, metric, timeout, retry, cache, auth, rate limit, mã hoá.
  • Bạn cần tổ hợp tự do các trách nhiệm theo nơi dùng (refund không retry, payment retry 3, job retry 10) — cây if/opts không diễn tả nổi.
  • Bạn không được phép sửa code gốc: SDK vendor, thư viện, module của team khác — nhưng cần thêm timeout/cache/validation quanh nó.
  • Bạn muốn test logic lõi mà không có I/O, rồi bật từng tầng lên khi cần kiểm chứng hành vi thật.
  • Hành vi phải bật/tắt được lúc chạy theo env, tenant, feature flag, mà không đụng code nghiệp vụ.
  • Cảnh giác ngược lại: một trách nhiệm, một chỗ dùng, không bao giờ tắt — đừng bọc, viết thẳng.

Đừng dùng khi

  • Over-engineering. Một lần dùng duy nhất + không có tổ hợp nào phải chọn = decorator là một file indirection và một lần nhảy định nghĩa. Pattern này đáng giá khi có ≥ 2 decorator hoặc ≥ 2 nơi dùng cùng policy.
  • Thứ tự tầng là bug mới của bạn. Cache trong retry sẽ cache luôn cả đáp án lỗi; metric trong retry sẽ không tính thời gian retry; auth trong cache sẽ trả dữ liệu của user khác cho user tiếp theo. Vẽ stack ra giấy khi thêm tầng thứ ba.
  • Nhiều tầng làm debug dài ra: stack trace dày 6 frame wrapper, exception được "diễn giải lại" ở mỗi tầng. Mỗi decorator phải giữ nguyên lỗi gốc (đừng catch (e) { throw new Error("gọi API thất bại") } rồi ném hết thông tin gốc) và log kèm tag của tầng mình.
  • Decorator không trong suốt với instanceof, với this khi trích method, và với số lần gọi. Retry nhân side effect: nếu API không idempotent, retry của bạn là charge tiền hai lần.
  • Decorator không phải @decorator trong TypeScript, và cũng không phải AOP của Java. Nói "decorator" trong team, hãy nói rõ bạn đang nói object runtime hay cú pháp @ — hiểu nhầm này sinh ra những cuộc họp rất dài.

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

Trong code thật

p-retry, p-timeout, p-memoize, p-limit

Cả họ package của sindresorhus đúng là decorator dạng function: pTimeout(promise, { milliseconds }) trả về một promise đã được bọc hành vi timeout, pMemoize(fn) trả về một function cùng shape đã có cache, pLimit(3) bọc một hàm async để giới hạn số lần chạy đồng thời. Bạn xếp pLimit(withRetry(...)) theo thứ tự — chính xác là câu chuyện stack ở Bước 3.

Nitro defineCachedEventHandler và wrapper middleware trong Nuxt

defineCachedEventHandler(handler, opts) nhận một event handler, trả về một event handler, thêm cache + lock + stale-while-revalidate phía sau — handler của bạn không đổi. Cùng hình dạng: defineNuxtRouteMiddleware cho phép viết withAuth(handler) trả về middleware mới. h3/nitro đầy những hàm "nhận handler, trả handler".

React HOC và composable Vue

React.memo(C), connect(mapState)(C), withTranslation(C), React.forwardRef(C) đều nhận một component và trả về một component — decorator của component, xếp chồng được, và thứ tự có nghĩa (memo trong hay ngoài connect cho perf khác nhau). Vue đi hướng khác nhưng cùng hình: composable nhận ref/state, trả về ref/state đã thêm hành vi (useFetch + retry + debounce tự viết).

Zustand middleware và Express compression()

create(persist(creator, { name })) trong Zustand: persist nhận state creator, trả về state creator đã thêm ghi/đọc localStorage — decorator thuần. Ở phía server, compression() trong Express bọc res.write/res.end để gzip stream response: decorator áp lên method của một object đang sống, anh em ruột với Proxy.

08 — Tự tay làm

Bài tập

Bạn có `type Sender = (phone: string, text: string) => string`. Viết `withRateLimit(inner: Sender, perMinute: number): Sender` và `withAudit(inner: Sender): Sender`, rồi ghép hai trường hợp: (a) audit phải ghi **kết quả cuối cùng** sau khi đã rate-limit, (b) audit phải ghi **mọi lần bị từ chối**. Trả lời: stack nào cho từng trường hợp?

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

  1. Mỗi decorator phải trả về đúng shape Sender, nếu không chúng không bọc được nhau.
  2. withRateLimit cần state (đếm số lần trong cửa sổ 1 phút) — state đó nằm trong closure, chú ý mỗi lần gọi withRateLimit phải có bộ đếm riêng.
  3. Câu hỏi thứ hai chỉ là thứ tự: audit ngoài cùng nhìn thấy kết quả cuối; audit nằm trong (gần sender hơn) nhìn thấy từng lần bị từ chối.

Cả hai câu chỉ khác nhau ở thứ tự. (a) withAudit(withRateLimit(send, 5)): limiter chạy trước, trả về LIMITED ... khi vượt; audit ở ngoài ghi đúng một dòng cho kết quả cuối (hoặc cho lý do bị chặn). (b) withRateLimit(withAudit(send), 5): limiter quyết định trước, nhưng với audit, audit không ghi gì cho các lần bị chặn; để ghi cả những lần bị từ chối thì đặt audit ngoài cùng như (a) và để limiter trả về kết quả có chữ LIMITED — audit sẽ log nguyên văn cả hai loại. Bài học: "ai thấy gì" được quyết định hoàn toàn bởi thứ tự stack.

tsbai-tap.ts
type Sender = (phone: string, text: string) => string

const send = (phone: string, text: string): string =>
  'SENT ' + phone + ' (' + text.length + ' ký tự)'

function withRateLimit(inner: Sender, perMinute: number): Sender {
  const hits: number[] = []
  return (phone, text) => {
    const now = 1_000 // thế bằng Date.now() trong code thật
    while (hits.length && now - hits[0] > 60_000) hits.shift()
    if (hits.length >= perMinute) return 'LIMITED ' + phone
    hits.push(now)
    return inner(phone, text)
  }
}

const withAudit = (inner: Sender): Sender =>
  (phone, text) => {
    const out = inner(phone, text)
    console.log('[audit] ' + out)
    return out
  }

const sms = withAudit(withRateLimit(send, 2))
console.log('--- khach: chi log ket qua cuoi ---')
sms('0912', 'a')
sms('0912', 'bb')
sms('0912', 'ccc')

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

Pattern liên quan

  • ProxyCùng hình dạng (một object đứng giữa, giữ reference), khác ý đồ: Proxy **kiểm soát truy cập** (lazy, quyền, remote, copy-on-write), Decorator **thêm trách nhiệm nghiệp vụ**. Nhiều Proxy cũng là decorator, và ngược lại — đọc cặp này để phân biệt theo mục đích, không theo sơ đồ.
  • AdapterAdapter **đổi** interface cho khớp (`pay()` → `send()`), Decorator **giữ nguyên** interface và thêm hành vi. Nếu decorator của bạn khai báo interface khác cái nó bọc, đó là Adapter đội lốt.
  • Chain of ResponsibilityMiddleware trong Express/Nuxt nhìn giống Decorator nhưng là Chain of Responsibility khi mỗi tầng có quyền **từ chối** xử lý tiếp. Decorator thì tầng nào cũng buộc gọi tầng bên trong cho xong việc.
  • StrategyStrategy **thay** cách làm (chọn một trong nhiều); Decorator **thêm** quanh cách làm cũ và cộng dồn được. `new WithRetry(gateway)` + `new WithLog(gateway)` = cả hai; `gateway = registry[driver]` = Strategy.