Pattern 15/22 · Structural

Proxy Đại diện

Đặt một vật thay thế đứng trước object thật: client cầm proxy và không phân biệt được, còn proxy quyết định khi nào object thật bị chạm tới, chạm những gì, và có được chạm không.

Cấu trúc●●●14 phút đọc8 bướccòn gọi: Surrogate, Delegation (họ hàng); Virtual / Cache / Protection / Remote proxy
structuralProxyreactivitylazy loadinginterceptionvue

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

Vấn đề

Trang admin có bảng đơn hàng. Data loader của bạn getOrder(id) kéo một lúc order + 4 bảng liên quan, mất ~60ms. Nhưng 80% lượt mở trang chỉ để xem status trong drawer. Bạn biết điều đó. Code của bạn thì không: nó load hết, ngay, mỗi lần, vì "cần gì thì gọi getOrder".

Vấn đề thứ hai, N+1. Danh sách 200 đơn, mỗi dòng chạm order.customer.address → 200 query. Bạn sửa được bằng cách nhớ viết batch ở từng chỗ dùng. Ai quên một chỗ — và sẽ có người quên — là sập một lần.

Vấn đề thứ ba, quyền. user.passwordHash nằm trong object, một component tình cờ JSON.stringify(user) để log, và hash đi lạc xuống browser. Bạn đã check permission ở 14 chỗ, mỗi chỗ một kiểu; một chỗ thiếu là một lần lộ dữ liệu, và không có chỗ nào để "siết một lần".

Vấn đề thứ tư, reactivity. state.count++ phải kéo theo re-render. Muốn thế, object phải thấy được từng thao tác đọc/ghi. Hoặc là bạn bắt mọi người viết set("count", v) (cả team sẽ chửi), hoặc bạn phải có thứ gì đó đứng giữa và chặn access.

Bốn bài toán trên trông chẳng liên quan, nhưng chung một hình: client cần một object, nhưng object thật không nên bị chạm tới tuỳ tiện, hoặc mỗi lần chạm tới đều phải được ghi lại. Và cách sửa "thêm một if vào đầu mỗi hàm dùng" nhân bản theo số call site — cùng cái bệnh, cùng cái giá.

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

Giải pháp

Proxy là: một vật thay thế cùng interface với object thật, client không phân biệt được, nằm giữa client và object thật (gọi là subject/proxyee) để quyết định. Nó giữ reference tới subject, cộng với lý do tồn tại: chưa load gì (virtual), đã load gì (cache), ai được thấy gì (protection), ai cần được báo (logging/reactivity), ở machine nào (remote).

TypeScript/JavaScript cho bạn bản literal nhất của pattern này, không phải bản mô phỏng: new Proxy(target, handler) — engine gọi trap của bạn cho từng phép get, set, has, deleteProperty, ownKeys, apply, construct. Vue 3 hiện thực reactive() đúng bằng Proxy: trap get để track dependency, trap set để trigger effect. Khi bạn viết state.a.b++, có một proxy đứng giữa, và đó chính là Proxy pattern của GoF, bằng API chuẩn.

Cái giá cũng phải nói đủ: mọi access đi qua một trap (chậm hơn access thường, và trong loop nóng thì đo ra chứ không đoán), this trong method khi gọi qua proxy là proxy (đôi khi là thứ bạn muốn, đôi khi là bug), private #field và các object có internal slot (Map, Set, Date, typed array) vỡ khi bọc proxy, và debugger/stack trace khó đọc hơn vì object bạn thấy không phải object bạn tạo. Đặt proxy ở biên giới, đừng rải khắp codebase.

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

Từng bước một

1

Gọi tên lý do: bốn loại proxy, đừng nhét chung một file

Trước khi viết trap, chọn một lý do. Virtual proxy: trì hoãn việc tạo/load subject. Caching proxy: giữ kết quả để đừng tính/lấy lại. Protection proxy: quyết định ai được thấy/cái gì. Logging/reactive proxy: ghi lại hoặc phát thông báo mỗi lần access. Remote proxy: subject nằm ở process/host khác (JSON-RPC, tRPC client).

Lý do thứ năm là "cho gọn" — đó là Facade, không phải Proxy. Proxy giữ nguyên interface của subject; nếu bạn đổi interface cho dễ dùng, bạn đang làm pattern khác.

textloai-proxy.ts
virtual     : Order  -> gọi DB lần đầu tiên ai đó chạm field     (lazy)
caching     : fn(sku)-> Map  -> chỉ gọi fn khi miss              (memoize)
protection  : user   -> Set  -> field nào được lộ                (role)
reactive    : state  -> Set  -> ai đọc gì, ai cần chạy lại       (signal)
remote      : api    -> socket -> method name + args đi network

Facade  : đổi interface cho ĐƠN GIẢN.
Adapter : đổi interface cho KHỚP.
Proxy   : GIỮ interface, thêm quyền quyết định ở giữa.
Nếu bạn không chỉ được một dòng trong số này, bạn chưa cần proxy — bạn cần một cái hàm.
ChốtMỗi proxy một lý do. Một file vừa lazy vừa cache vừa check role là một file bạn sẽ không dám sửa.
2

HÌNH DẠNG trap trong JS: new Proxy(target, handler)

handler là object chứa các trap; trap nào bạn không khai báo thì hành vi mặc định đi thẳng tới target. Đây là lý do proxy "trong suốt": 99% thao tác không bị chạm.

Hai ràng buộc hay gặp: trap set phải trả true khi thành công (không thì code ở chế độ strict mode ném TypeError), và trap không được nói dối trắng trợn — invariant của engine cấm get trả khác target với property non-configurable, và cấm has trả false cho property non-configurable đang tồn tại.

tstrap-shape.ts
const target: Record<string | symbol, unknown> = { role: 'guest', name: 'Khanh' }

const p = new Proxy(target, {
  get: (obj, key) => (key in obj ? obj[key] : 'missing'),
  set: (obj, key, value) => {
    obj[key] = value
    return true // quên: không return true -> strict mode throw
  },
  has: (obj, key) => key !== 'role',            // 'role' in p -> false
  deleteProperty: () => false,                   // delete p.name -> throw (strict)
})

p.role          // 'guest'
'role' in p     // false
delete p.name   // TypeError: not allowed
p.age = 3       // target.age === 3: target bị sửa THẬT
Proxy mặc định là transparent. Bạn chỉ can thiệp đúng những trap bạn khai báo.
ChốtKhai báo ít trap nhất có thể. Mỗi trap thêm một chỗ để hành vi lệch khỏi những gì TypeScript hứa.
3

Virtual proxy: chưa đụng DB cho tới khi thật sự cần

Đây là lời giải cho bài toán 60ms. Client cầm order, code của nó không đổi một dòng, nhưng loadOrderFromDb chỉ chạy khi có ai đó chạm vào một field thật sự cần dữ liệu. Handler chỉ đọc id (thứ đã có) sẽ không trigger query.

Chú ý phần chìm: in, Object.keys, JSON.stringify cũng đi qua trap (has, ownKeys, getOwnPropertyDescriptor). Proxy lazy mà chỉ viết get thì sẽ trả "thiếu field" cho mấy phép đó. Đây là chỗ proxy dễ sai nhất trong đời thực.

tslazy-order.ts
function lazyOrder(id: string): Order {
  let real: Order | null = null
  const load = () => (real ??= loadOrderFromDb(id)) // 60ms, JOIN 4 bảng

  return new Proxy({} as Order, {
    get: () => load() as Order,                       // mọi field: load rồi trả
    has: (_t, key) => key in load(),
    ownKeys: () => Reflect.ownKeys(load()),
    getOwnPropertyDescriptor: (_t, key) => Reflect.getOwnPropertyDescriptor(load(), key),
  })
}

const order = lazyOrder('DH-01') // 0 query, 0 ms
console.log(order.status)        // 1 query, vì bạn thật sự cần status
Cùng một proxy: code đọc id thì rẻ, code đọc items thì trả giá. Client không cần biết sự khác biệt.
ChốtVirtual proxy biến "load sớm cho an toàn" thành quyết định có thể hoãn tới sát lúc dùng.
4

Caching proxy: chặn một hàm đắt, và sống chung với invalidation

Bọc hàm cũng là proxy: trap apply bắt mọi lời gọi. Memoize theo key ở trong trap nghĩa là mọi call site được cache mà không call site nào phải đổi — và không call site nào được phép "tự cache riêng" nữa.

Hai điều bắt buộc nếu không muốn cache thành bug: không cache thất bại (lỗi là trạng thái tạm, cache nó là bạn đóng băng hỏng), và phải có đường invalidate — nếu không, proxy của bạn là một cái memory leak biết trả lời.

tsmemo-proxy.ts
const cache = new Map<string, Promise<Product>>()

export const getProduct = new Proxy(fetchProduct, {
  apply: (fn, _self, args: [string]) => {
    const hit = cache.get(args[0])
    if (hit) return hit

    const p: Promise<Product> = fn(args[0]).catch((e) => {
      cache.delete(args[0]) // lỗi là tạm thời: không được cache vĩnh viễn
      throw e
    })
    cache.set(args[0], p)
    return p
  },
})

export const invalidate = (sku: string) => cache.delete(sku)
Cache nằm ở một chỗ, nên invalidate cũng có một chỗ. Đó là lý do dùng trap thay vì sửa từng call site.
ChốtProxy của hàm chỉ đáng khi cache là chính sách của cả hệ; một call site duy nhất thì closure memoize là đủ.
5

Protection proxy: chắn field theo vai trò — và hiểu đúng giới hạn

Muốn "siết một lần" thay vì check ở 14 chỗ: liệt kê field được phép trong một Set, và chặn ở bốn trap — get, has, ownKeys, getOwnPropertyDescriptor — vì JSON.stringify đi qua ownKeys cộng get, còn phép in đi qua has. Chặn một get là chặn hình thức.

Giới hạn, nói thẳng: proxy không phải ranh giới bảo mật trong cùng tiến trình. Code nào cầm được reference tới row gốc thì đi vòng qua bạn, và secret đã nằm trong target thì coi như đã nằm trong RAM của attacker. Proxy kiểu này hợp pháp với tư cách guardrail chống vô tình (log, serialize, render nhầm); muốn chắn thật thì đừng đưa secret vào object: chọn cột ở query, trả projection.

tspublic-view.ts
const PUBLIC = new Set(['id', 'name', 'verifiedAt'])

export function asPublic(row: UserRow) {
  return new Proxy(row, {
    get: (o, k) => (PUBLIC.has(String(k)) ? (o as Record<string | symbol, unknown>)[k] : undefined),
    has: (_o, k) => PUBLIC.has(String(k)),
    ownKeys: () => [...PUBLIC],
    getOwnPropertyDescriptor: (o, k) =>
      PUBLIC.has(String(k)) ? Reflect.getOwnPropertyDescriptor(o, k) : undefined,
  })
}

JSON.stringify(asPublic(row)) // {"id":..,"name":..,"verifiedAt":..} - không có passwordHash
Guardrail chống vô tình, không phải tường lửa. Secret thật thì phải mất từ query, không mất ở đây.
ChốtProtection proxy chặn được tai nạn, không chặn được cố ý. Đừng nhầm hai việc đó.
6

Reactive proxy: trap set là nơi sự thật nằm

reactive, signal, $state — tất cả cùng một cơ chế: phát hiện thay đổi tại chỗ ghi. Với proxy, không cần setter, không cần API riêng: phép state.count++ là một trap set.

Vue 3 là ví dụ chuẩn và đáng học: reactive(obj) trả proxy; trap get track (ghi lại effect nào đang đọc field nào), trap set/deleteProperty trigger (chạy lại effect liên quan). Object lồng nhau được wrap lười ngay trong trap get (đó là cách nó deep mà không tốn trước), in đi qua has, và Map/Set có handler riêng vì lý do ở Bước 7. Vue 2 không làm được vậy vì Object.defineProperty không thấy được thêm/xoá key.

tsreactive.ts
const subs = new Set<(key: string) => void>()

export function reactive<T extends object>(target: T): T {
  return new Proxy(target, {
    set: (obj, key, value) => {
      const changed = Reflect.get(obj, key) !== value
      const ok = Reflect.set(obj, key, value)
      if (ok && changed) subs.forEach(fn => fn(String(key))) // 1 dòng: cả app re-render
      return ok
    },
    deleteProperty: (obj, key) => {
      const ok = Reflect.deleteProperty(obj, key)
      if (ok) subs.forEach(fn => fn(String(key)))
      return ok
    },
  })
}

export const onChange = (fn: (key: string) => void) => (subs.add(fn), () => subs.delete(fn))
Năm dòng này là toàn bộ "phép màu" reactivity. Proxy biến mutating code thành source of truth có thể nghe ngóng.
ChốtProxy cho bạn hook ở đúng chỗ thao tác xảy ra, nên code dùng state không phải đổi một dòng nào.
7

Ba cái bẫy kỹ thuật: this, private field, internal slot

Bẫy 1 — this. Gọi p.method() thì bên trong method, this là proxy (thứ mà reactivity cần, nhưng cũng là chỗ sinh bug). Tách method ra khỏi object (const fn = p.method; fn()) thì this thành undefined y như object thường, và method đọc this.x sẽ nổ.

Bẫy 2 — private #field. Private field không phải property; nó là internal slot, nên trap không thấy và brand check thất bại: đọc #pin qua proxy ném TypeError (thông điệp khác nhau tuỳ engine). Bẫy 3 — object có internal slot còn cay hơn: Map, Set, Date, typed array cần slot nội bộ của chính object, nên bọc proxy làm method của chúng hỏng — new Proxy(new Map(), {}).set(...) ném "incompatible receiver". Array thì sống, vì array chỉ là object + length.

tsgotchas.ts
class Account {
  #pin = '1234'
  name = 'bank'
  whoami() { return this.name }
  readPin() { return this.#pin }
}

const p = new Proxy(new Account(), {})
p.whoami()            // 'bank'  -> this LÀ proxy, vẫn đúng

const fn = p.whoami   // tách method: mất this binding
// fn()               // TypeError: không đọc được this.name

// p.readPin()        // TypeError: private field không qua được trap

const m = new Proxy(new Map<string, number>(), {})
// m.set('a', 1)      // TypeError: không phải Map thật (thiếu internal slot)
const d = new Proxy(new Date(), {})
// d.getTime()        // TypeError, tương tu

const a = new Proxy([1, 2, 3], {})
a.push(4)             // OK: array không cần internal slot
console.log(a.length) // 4
Cả bốn dòng TypeError ở trên đều là lỗi thật, chạy được, không phải lý thuyết.
ChốtProxy bọc được dữ liệu thường, không bọc được object mà behaviour sống trong internal slot. Muốn reactive Map/Set: tự viết collection, như Vue 3 đã làm.
8

Bước cuối: cân nhắc đừng dùng Proxy

Proxy là công cụ biên giới: một lớp mỏng ở nơi data đi vào/ra, nơi bạn kiểm soát được toàn bộ lưu lượng. Rải reactive()/proxy wrapper khắp 200 module là cách nhanh nhất để profiler của bạn đầy trap và debugger của bạn vô dụng.

Đa số nhu cầu có bản rẻ hơn: cần field tính toán → getter. Cần cache một hàm → một closure memoize, không cần apply trap. Cần N+1 hết → DataLoader/batch loader ở tầng repository. Cần "đừng sửa config" → Object.freeze + type readonly. Cần "đừng import lung tung" → lint rule ở tầng module. Proxy thắng khi bạn cần chặn cả một họ access mà không sửa call site — không thì đừng.

textcheapest-option.ts
cần gì                    -> bản rẻ hơn        Proxy xứng khi
field tính toán           -> getter           không có access nào cần chặn
cache 1 hàm               -> closure memoize  MỌI call site phải đi qua cache
N+1 query                 -> DataLoader       access nằm rải rác, khó kiểm soát
config cấm sửa            -> Object.freeze    bạn chỉ cần nó đừng bị sửa
kiểm thử/audit access     -> Proxy (trap)     đây là việc duy nhất trap làm được
Viết bảng này ra file README của module trước khi mở editor viết trap.
ChốtProxy là quyền lực và quyền lực thì đắt. Lý do dùng nó phải là "tôi không sửa nổi từng call site", không phải "nghe ngầu".

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

Cấu trúc

  • Subject (interface)Hình dạng mà client mong đợi. Proxy **phải** giống hệt — đây là điều kiện để client không phân biệt được.
  • ProxyVật thay thế: giữ reference tới subject + **lý do** (lazy, cache, role, tracking). Chạm trap mới đi tiếp tới subject.
  • Proxyee / RealSubjectObject thật: row từ DB với 4 bảng JOIN, hàm đắt, tài nguyên remote. Chậm, đắt, hoặc nhạy cảm.
  • ClientĐọc/ghi qua proxy như đọc object thường. Không biết (và không cần biết) có gì ở giữa.
  • Observer(phien bản reactive) Đăng ký nhận thông báo khi trap `set`/`deleteProperty` bắt được thay đổi.
   Client                 Proxy (handler)              Proxyee (thật)
   ------                 -----------------            --------------
   order.status  ──get──► │ get: load nếu chưa có      │
   order.items   ──get──► │ set: ghi + báo subscriber  │  60ms,
   'items' in    ──has──► │ has/ownKeys: ẩn field nhạy │  4 JOIN
   JSON.stringify ──────► │ apply: memoize theo key    │  nhạy cảm
                          └──────────┬─────────────────┘
                                     │ chỉ đi tiếp khi trap cho phép
                                     ▼
                          trap = điểm can thiệp DUY NHẤT, ở một chỗ,
                          client không đổi một dòng nào

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

Chạy thử: ba trap, ba lý do, trong 40 dòng

tsdemo.ts
const dirty = new Set<string>()

// 1) Reactive proxy: trap set phát hiện thay đổi (bản rút gọn của Vue 3 reactive())
const state = new Proxy({ cart: 0, coupon: '' } as Record<string | symbol, unknown>, {
  set: (obj, key, value) => {
    const changed = obj[key] !== value
    obj[key] = value
    if (changed) dirty.add(String(key))
    return true
  },
})
state.cart = 1
state.cart = 1 // không đổi -> không dirty, key không bị thêm lần nữa
state.coupon = 'SALE50'

// 2) Caching proxy: chặn một hàm đắt, memoize theo argument
let dbCalls = 0
const priceOf = (sku: string) => {
  dbCalls++
  return sku.length * 10
}
const cache = new Map<string, number>()
const price = new Proxy(priceOf, {
  apply: (fn, _self, args: unknown[]) => {
    const key = String(args[0])
    if (!cache.has(key)) cache.set(key, fn(key))
    return cache.get(key)
  },
})

// 3) Access-control proxy: khách được thấy field nào, chỉ vậy thôi
const row = { sku: 'A1', cost: 40, margin: 0.6 }
const allowed = new Set(['sku', 'cost'])
const guestView = new Proxy(row, {
  get: (o, k) => (allowed.has(String(k)) ? (o as Record<string | symbol, unknown>)[k] : undefined),
  has: (_o, k) => allowed.has(String(k)),
})

console.log('dirty: ' + [...dirty].join(','))
console.log('price x3 = ' + [1, 2, 3].map(() => price('A1')).join('/') + ' dbCalls=' + dbCalls)
console.log('guest sku=' + guestView.sku + ' margin=' + guestView.margin + ' hasMargin=' + ('margin' in guestView))
console
dirty: cart,coupon
price x3 = 20/20/20 dbCalls=1
guest sku=A1 margin=undefined hasMargin=false

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

  • Trì một chi phí lớn cho tới sát lúc cần, và giao diện gọi không được phép đổi (lazy relation, hydrate theo field, lazy row).
  • Cần bắt mọi access ở một điểm: cache, audit log, telemetry, permission — mà không sửa hàng chục call site.
  • Cần state mà mutation thật (obj.x = 1) vẫn phát hiện được: reactive store, signal, draft copy-on-write.
  • Cần một view bớt quyền của object (role, tenant, chế độ preview) thay vì tự tay projection ở mỗi route.
  • Subject nằm ở nơi khác (process, network) mà client vẫn muốn gọi như object local — RPC client, tRPC-style stub.
  • Cần kiểm chứng access trong test/dev: chặn ghi vào config, phát hiện ai đọc field đã deprecated.

Đừng dùng khi

  • Proxy không phải sandbox. Code cùng tiến trình cầm reference tới target là đi vòng qua bạn; secret đã vào target thì đã vào RAM. Chắn thật = projection từ query, không phải trap.
  • Object có internal slot vỡ thật: Map, Set, Date, typed array, WeakMap, Promise (instance gốc) — method của chúng require slot riêng, bọc proxy vào là TypeError. Array sống sót, đừng suy ra quy luật từ array.
  • this là proxy, nên mỗi this.x trong method lại đi qua trap (nhanh chậm tuỳ loop), còn method bị tách khỏi object thì mất binding và nổ. Proxy + class nhiều method là nơi bug ở lâu nhất.
  • Private #field vô hình với trap. Logic của bạn trong trap không thấy chúng, và truy cập chúng qua proxy ném TypeError. Nếu class của bạn sống bằng private state, proxy bọc không phải thiết kế khả thi.
  • Chỉ viết trap get là bug tiềm ẩn: in, Object.keys, JSON.stringify, structuredClone, spread đều đi qua has/ownKeys/getOwnPropertyDescriptor. Thiếu một trap là hành vi lệch âm thầm.
  • Chi phí thật: mỗi access một trap, và proxy lồng proxy (deep reactive) thì số trap nhân lên. Trong vòng lặp nóng, Map thường vẫn nhanh hơn object bọc proxy — đo, đừng tin blog.
  • Over-engineering. Rải proxy wrapper khắp codebase rồi báo "state giờ reactive" — profiler đầy trap, debugger mù, không ai giải thích được vì sao một phép đọc field chạy tới ba hàm. Getter giải quyết được thì đừng nhân bản proxy.
  • Đừng nhầm với HTTP proxy trong config: routeRules.proxy của Nuxt hay server.proxy của Vite là reverse proxy ở tầng mạng — cùng tinh thần "đứng giữa", khác hẳn pattern object này.

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

Trong code thật

Vue 3 reactive() / ref()

reactive(obj) trả new Proxy(obj, handler) với trap get (track), set, deleteProperty, has, ownKeys; object lồng nhau được wrap lười trong trap get; Map/Set đi qua collection handler riêng vì internal slot. Vue 2 không làm được vậy vì Object.defineProperty không thấy thao tác thêm/xoá key — chính là lý do API Vue.set tồn tại.

Immer produce()

Immer dựng draft bằng Proxy: trap get trả draft lồng nhau, trap set ghi vào bản copy (copy-on-write), rồi produce trả object bất biến mới. Bạn mutate bình thường, library nghe trộm qua trap để tính diff — Proxy pattern đứng nguyên dưới API.

DataLoader

Một object thay thế đứng trước hàm load, memoize theo key trong phạm vi một request và gộp các load thành một batch. Nó không phải new Proxy, nhưng về hình dạng, đó là caching + batching proxy: call site gọi loader.load(id) và không biết gì ở giữa.

Lazy relation trong ORM

TypeORM cho phép khai báo quan hệ kiểu Promise<Entity> và nó được nạp khi bạn chạm property — virtual proxy bằng getter, không cần new Proxy. Cùng lý do tồn tại, khác cơ chế: khi số field nhỏ và cố định, getter đơn giản hơn.

require() cache của Node

Mỗi lần require, runtime tra Module._cache trước, đụng filesystem chỉ khi miss. Về bản chất đó là caching proxy che một subsystem đắt, và nó cũng dạy luôn bài học invalidate: cache module sống dai, và bạn trả giá đó lúc hot reload.

08 — Tự tay làm

Bài tập

Viết `readonlyGuard(config, "config")` trả về proxy mà mọi attempts `set`, `deleteProperty`, `defineProperty` ném Error ghi rõ **key nào, thao tác gì**. Gắn nó vào config của app trong dev. Sau đó trả lời hai câu: vì sao `config.db.host = "x"` vẫn trót lọt, và vì sao đây không phải cơ chế bảo mật.

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

  1. Cả ba trap phải ném cùng một loại lỗi — hãy viết một helper deny(op, key) trả về never rồi dùng chung.
  2. Trap set muốn "chặn" thì ném Error, chứ không chỉ trả false (trả false chỉ ném ở strict mode và mất thông điệp).
  3. Bản "sâu" (deep) phải wrap tiếp ở trap get: mỗi lần trả về một object thì bọc nó — đó chính xác là cách Vue 3 reactive xử lý object lồng nhau.

Ba trap gọi chung một deny(), nên thông điệp lỗi nhất quán và bạn không lặp code. Bản wrap-sâu: trong trap get, nếu giá trị là object thì trả readonlyGuard(value) (đừng quên memo theo object gốc để mỗi object chỉ một proxy — đây là flyweight gặp proxy). Còn câu hỏi bảo mật: guard này chặn tai nạn, không chặn người cố tình — họ vẫn còn object gốc trong scope, và proxy không có tác dụng gì với code không đi qua nó.

tsbai-tap.ts
function readonlyGuard<T extends object>(obj: T, path: string): T {
  const deny = (op: string, key: string | symbol): never => {
    throw new Error(path + ' is readonly: ' + op + ' "' + String(key) + '"')
  }

  return new Proxy(obj, {
    set: (_t, key) => deny('set', key),
    deleteProperty: (_t, key) => deny('delete', key),
    defineProperty: (_t, key) => deny('define', key),
    // deep: object lồng nhau cũng phải bị giữ
    get: (o, key) => {
      const value = Reflect.get(o, key)
      return value && typeof value === 'object' ? readonlyGuard(value, path + '.' + String(key)) : value
    },
  })
}

const config = readonlyGuard({ db: { host: 'localhost' }, port: 3000 }, 'config')
config.port = 8080          // Error: config is readonly: set "port"
config.db.host = 'evil'     // Error: config.db is readonly: set "host"

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

Pattern liên quan

  • FacadeCả hai đều "đứng trước" thứ khác nhau. Facade **đổi** interface để subsystem dễ dùng; Proxy **giữ** interface để kiểm soát truy cập. Nếu client của bạn phải học API mới, đó không còn là Proxy.
  • DecoratorDecorator thêm hành vi bằng cách bọc **tĩnh và chủ ý** — ai viết code đó đều biết có lớp bọc. Proxy thêm hành vi **trong suốt** — client không phân biệt được. Decorator rẻ và dễ debug hơn, chỉ khi cần chặn toàn bộ access mới tới lượt Proxy.
  • AdapterAdapter tồn tại vì interface **không khớp**; Proxy tồn tại vì việc **truy cập** cần bị kiểm soát, và nó cố tình không sửa interface.
  • CommandCặp hay gặp ở remote proxy: proxy dịch mỗi lời gọi method thành một Command object, gửi đi, bên kia chạy rồi trả kết quả. RPC client thực chất là proxy sinh command.