Pattern 21/22 · Behavioral
Memento Bản chụp trạng thái
Chụp trạng thái của một object thành một gói kín để khôi phục sau này, mà không buộc object phải lộ field internal cho người giữ gói đó.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Editor của bạn — form sản phẩm trong CMS, đơn hàng ở trang admin, hoá đơn — có 12 field, hai mảng lồng nhau (variants[], images[]) và một publishedAt: Date. Sprint này có yêu cầu "app gì mà không có Ctrl+Z". Bạn thấy dễ: state là object, undo là pop() khỏi một mảng.
Bạn viết this.history.push(this). Bấm sửa ba lần, nhấn undo, không có gì thay đổi. push(this) nhét con trỏ vào mảng: history hiện là 40 pointer trỏ vào đúng một object đang sống, nên "snapshot cũ" và "hiện tại" là một. Đây không phải bug logic, nó là bug của mô hình tinh thần — bạn tưởng mình lưu trạng thái, bạn lưu địa chỉ.
Bản sửa tiếp theo cũng sai, theo cách riêng: history.push({ ...this }). Copy nông giữ nguyên tham chiếu tới variants, nên người dùng thêm một variant thì mọi snapshot cũ cùng lớn theo. Chuyển sang JSON.parse(JSON.stringify(this)) thì sạch hơn nhưng âm thầm phá: Date hoá string, Map/Set thành {}, key có giá trị undefined bốc hơi, class identity và mọi method biến mất. Với form 2MB, mỗi lần chụp thêm 2MB allocation và một lần parse.
Rồi tới nước "giải cứu": bỏ private cho hết field, thêm restoreAll(state: any) cho undo khỏi vất vả. Encapsulation bốc hơi. Từ lúc đó bất kỳ file nào cũng có thể viết form.price = 0, form.variants = [], đi vòng qua toàn bộ validation bạn đặt trong setPrice(). Bạn vừa trả giá bằng sự an toàn của cả class, trong khi undo không cần đọc field nào — nó chỉ cần giữ hộ một gói.
Chi phí thứ hai, hầu như không ai thiết kế trước: bộ nhớ. Autosave mỗi 500ms trên editor 2MB, một tab SPA mở cả ngày không reload → 120 snapshot/giờ → hơn 200MB/giờ. Undo stack là memory leak kinh điển của app sống lâu, và nó phình vì không ai đặt trần số lượng.
02 — Ý tưởng, chưa động vào code
Giải pháp
Memento đóng đúng một vai: Originator (object có state) tự chụp trạng thái của mình thành một object riêng, và người giữ nó — Caretaker, tức undo stack, autosave queue, lịch sử deploy — không mở ra được. Caretaker được quyền cất, xếp, giới hạn số lượng, thải tuỳ ý; muốn khôi phục thì phải trả gói đó về cho Originator qua restore(memento).
"Tự chụp" và "không mở được" là toàn bộ pattern. Bỏ vế đầu, history của bạn alias với hiện tại (bug đoạn 2). Bỏ vế sau, bạn buộc phải public internal (bug đoạn 4). Có cả hai, snapshot() trả về một token rỗng ruột với người ngoài, còn Originator thì đọc lại được từng chữ.
Trong TS, dạng thực dụng nhất không cần class Memento trang trọng: một object bị đóng băng, chụp theo giá trị, do chính Originator sinh ra. Và vì mỗi snapshot tốn RAM thật, hãy tính tiền ngay từ đầu: chụp tại thời điểm có nghĩa (trước khi sửa, không phải mỗi keystroke), đặt trần số lượng, và với tài liệu lớn thì lưu diff thay vì nguyên bản.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Gọi tên ba vai trước khi viết dòng code nào
Originator: object sở hữu state và là nơi duy nhất biết state trông như thế nào (FormEditor, Cart, Doc). Memento: gói state, opaque với mọi người trừ Originator. Caretaker: giữ memento và quyết định khi nào quay lại (UndoManager, autosave, deploy history).
Viết hai interface này ra trước sẽ chặn luôn hai bug ở bước 2 và 4, vì chúng buộc bạn trả lời: ai được chụp, ai được mở.
// Originator : có state, TỰ chụp, TỰ mở
interface Originator<M> {
snapshot(): M
restore(m: M): void
}
// Caretaker : giữ memento nhưng KHÔNG biết memento chứa gì
class History<M> {
private items: M[] = []
push(m: M) { this.items.push(m) } // cất thôi, không đọc
get length() { return this.items.length }
at(i: number): M { return this.items[i] } // trả về đúng loại M, không giải mã
}History<M> không hề biết M là gì. Đó không phải tình cờ — đó là toàn bộ điểm mạnh của pattern.Bản "bad smell": `history.push(this)`
Code này chạy, không ném lỗi, và hoàn toàn vô dụng. Chạy thử để thấy tận mắt: undo in ra đúng giá trị hiện tại.
class FormEditor {
title = ''
history: FormEditor[] = [] // mảng này chứa GÌ?
edit(title: string) {
this.history.push(this) // <- push CON TRỎ, không phải trạng thái
this.title = title
console.log('edit -> ' + this.title)
}
undo() {
const prev = this.history.pop()
if (!prev) return console.log('undo -> het')
this.title = prev.title // prev === this, nên đây là title HIỆN TẠI
console.log('undo -> ' + this.title)
}
}
const f = new FormEditor()
f.edit('A')
f.edit('B')
f.undo() // mong đợi "A"edit -> A edit -> B undo -> B
history chứa ba pointer cùng trỏ một object. Không snapshot nào "cũ" cả.Copy nông, JSON round-trip, structuredClone — mỗi cái sai một kiểu
Ba cách "sửa nhanh" mà ai cũng thử. Biết chúng hỏng ở đâu quan trọng hơn biết cách dùng, vì nó quyết định bạn chọn gói snapshot thế nào ở bước 4.
const snap = { ...editor } // nông: variants VẪN LÀ MỘT MẢNG CHUNG
editor.variants.push({ sku: 'AO-2' })
console.log(snap.variants.length) // 2 <- snapshot "cũ" lớn theo hiện tại
const viaJson = JSON.parse(JSON.stringify(editor))
editor.publishedAt = new Date('2026-01-05')
console.log(typeof viaJson.publishedAt) // 'string' - Date đã thành text
console.log(viaJson.note) // undefined - key bốc hơi (JSON không có undefined)
console.log(viaJson.variants[0].isMain) // undefined - getter của class không phải own property
// structuredClone(editor): an toàn hơn JSON (giữ Date, Map, cycle) NHƯNG:
// - ném DataCloneError nếu state chứa function, DOM node, class instance có method
// - copy 100% mỗi lần: doc 3MB = 3MB cho MỖI bước undo{ ...x } alias với nested, JSON làm méo type, structuredClone an toàn nhưng đắt. Chọn cách copy là chọn chi phí — đừng mặc định.Originator tự chụp, chụp theo giá trị
Đảo chiều trách nhiệm: không ai được chụp state hộ editor. Originator phơi ra đúng một method snapshot(), và bên trong nó quyết định copy những gì, sâu tới đâu. Người ngoài không cần biết FormState có field gì hôm nay, hay tháng sau.
Dòng variants: [...this.state.variants] trông nhỏ: nó chính là dòng phân biệt Memento với bug ở bước 2. Chụp theo giá trị rồi mới gói lại.
type FormState = { title: string, price: number, variants: { sku: string }[] }
class FormEditor {
private state: FormState = { title: '', price: 0, variants: [] }
edit(patch: Partial<FormState>) {
this.state = { ...this.state, ...patch }
}
/** Originator TỰ chụp. Caretaker không biết shape, và không cần biết. */
snapshot(): Memento {
return new Memento({ ...this.state, variants: this.state.variants.map(v => ({ ...v })) })
}
/** Đường DUY NHẤT để mở gói. */
restore(m: Memento) {
this.state = m.unpack(this) // chỉ Originator được gọi (xem bước 5)
}
view() { return '"' + this.state.title + '" price=' + this.state.price + ' skus=' + this.state.variants.length }
}snapshot() là một phần API của Originator, không phải tiện ích bên ngoài. Nó đứng cùng file với state, và nó biết state sâu tới đâu.Đóng gói: Caretaker không mở được Memento
private của TypeScript tồn tại lúc compile và bị xoá sạch lúc chạy — history[0].state vẫn chạy ngon trong production. Dùng # (private của chính JS) để sự đóng gói là sự thật runtime, không phải lời khuyên của lint.
Không có getter cho state. Muốn debug, cho một accessor không lộ dữ liệu (bytes). Ai cần dữ liệu thật thì gọi restore() — và restore() thuộc về Originator.
export class Memento {
readonly #state: FormState
constructor(state: FormState) { this.#state = state } // # = private ở tầng JS
/** Đo chi phí thì được, đọc nội dung thì không. */
get bytes() { return JSON.stringify(this.#state).length }
/**
* "Unpack" chỉ hợp lệ khi người mở là chính Originator đã tạo gói này.
* Cách gọn: Originator truyền token bí mật, hoặc unpack là friend-method nội module.
*/
unpack(by: FormEditor): FormState { return this.#state }
}
const m = editor.snapshot()
m.title // TS2339: Property 'title' does not exist on type 'Memento'
;(m as any).state // undefined: không có property nào để mà mò
m.bytes // 118 - đủ để bạn biết snapshot này tốn bao nhiêu RAMCaretaker: history + cursor, undo/redo thật sự
Undo/redo đúng nghĩa là một mảng và một con trỏ, không phải push/pop. Con trỏ đứng giữa các snapshot. Chi tiết hay bị bỏ quên nhất: khi bạn sửa tiếp sau khi đã undo, nhánh redo phía sau con trỏ phải bị vứt — nếu không history thành một cây vô hình và redo bắt đầu đưa về trạng thái vô nghĩa.
Gắn vào Vue thì restore phải thay object state, đừng vá từng field: vá từng field nghĩa là field nào không có trong patch sẽ giữ giá trị cũ — "bóng ma" của lần sửa trước, và loại bug này cực khó lần vì nó phụ thuộc thứ tự thao tác.
export class UndoManager<M> {
private items: M[] = []
private cursor = -1
constructor(private limit = 50) {}
push(m: M) {
this.items = this.items.slice(0, this.cursor + 1) // cắt nhánh redo
this.items.push(m)
if (this.items.length > this.limit) this.items.shift()
this.cursor = this.items.length - 1
}
prev(): M | undefined { return this.cursor > 0 ? this.items[--this.cursor] : undefined }
next(): M | undefined { return this.cursor < this.items.length - 1 ? this.items[++this.cursor] : undefined }
}
// Caretaker không biết Memento chứa gì; nó chỉ đưa gói trả lại Originator.
const undo = () => { const m = history.prev(); if (m) editor.restore(m) }
const redo = () => { const m = history.next(); if (m) editor.restore(m) }
// Vue: state là ref -> gán nguyên object, một lần, hệ reactive tự lo phần còn lại.
const state = ref<FormState>({ title: '', price: 0, variants: [] })restore. Redo = tiến con trỏ. Sửa mới = cắt đuôi. Thiếu vế thứ ba thì history sai từ ngày thứ hai.Đặt trần bộ nhớ: ring buffer và ba cách cắt chi phí
Snapshot là RAM. Nhân lên rồi hãy quyết định: form nhẹ 2KB × 200 bước ≈ 400KB, chẳng sao; tài liệu 2MB × 200 bước ≈ 400MB, tab chết, và profiler mới là thứ nói sự thật chứ không phải code review.
Trần số lượng là bắt buộc với app sống lâu. Ring buffer (mảng tròn) là bản rẻ nhất: giữ N bản mới nhất, bản cũ nhất bị đẩy ra mà không cần splice. Đổi lại, người dùng quay lại quá N bước thì mất — đó là đánh đổi bạn phải nói rõ, không phải ẩn đi.
/** Mảng tròn: giữ N memento gần nhất, O(1) push, không cắt mảng. */
export class Ring<M> {
private buf: (M | undefined)[]
private head = 0
get length() { return this.n }
private n = 0
constructor(private size = 5) { this.buf = new Array(size) }
push(m: M) {
this.buf[this.head] = m
this.head = (this.head + 1) % this.size
this.n = Math.min(this.n + 1, this.size) // đầy rồi thì giữ nguyên n
}
at(back: number): M | undefined { // at(0) = mới nhất
if (back >= this.n) return undefined
return this.buf[(this.head - 1 - back + this.size * 2) % this.size]
}
}
// Ba đòn cắt chi phí, xếp theo hiệu quả thực tế:
// 1. Chụp theo EVENT CÓ NGHĨA (trước khi apply thay đổi), không phải mỗi keystroke
// 2. Debounce 300-500ms: "Ao thun" -> "Ao thun cotton" là MỘT bước, không 7 bước
// 3. Lưu diff thay vì nguyên bản (bước 8)Tài liệu lớn: chụp diff thay vì chụp tất cả
Editor thật (Monaco, CodeMirror 6, ProseMirror) không lưu 50 bản copy của cả tài liệu. Họ lưu operation có khả năng đảo ngược: mỗi bước chỉ ghi "insert 3 ký tự tại vị trí 120", và undo là chạy operation ngược. Bộ nhớ giảm từ O(steps × docSize) xuống O(steps × changeSize).
Cùng ý tưởng, quy mô nhỏ hơn: snapshot theo khu vực. Form 4 tab? Khi người dùng sửa tab "Vận chuyển", chỉ chụp tab đó. Undo của tab đó không đụng tab "Nội dung". Đây vẫn là Memento — chỉ là granularity do bạn chọn.
type Patch = { path: string, from: unknown, to: unknown }
/** Memento phiên bản "diff": gói chứa PHÉP ĐẢO, không chứa cả thế giới. */
class PatchMemento {
constructor(private patches: Patch[]) {}
static capture(patches: Patch[]) { return new PatchMemento(patches.map(p => ({ ...p }))) }
undoPatches(): Patch[] { return this.patches.map(p => ({ path: p.path, from: p.to, to: p.from })) }
redoPatches(): Patch[] { return this.patches }
}
const m = PatchMemento.capture([{ path: 'price', from: 250000, to: 199000 }])
apply(editor, m.undoPatches()) // undo: price 199000 -> 250000
apply(editor, m.redoPatches()) // redo: price 250000 -> 199000
// Đổi 1 field trong doc 2MB: patch 40 byte, thay vì snapshot 2MB.
// Cái giá: bạn phải viết apply(), và mọi thao tác phải express được thành patch có from/to.apply(). Chọn theo kích thước state, không theo sự ngầu.04 — Ai nói chuyện với ai
Cấu trúc
- OriginatorObject có state cần bảo vệ (`FormEditor`). Tự chụp `snapshot()`, tự mở bằng `restore(m)`. State là private.
- MementoGói trạng thái **bất biến**, chụp theo giá trị. Với người ngoài, nó không có field nào đọc được.
- CaretakerUndo stack / autosave queue / deploy history. Xếp, đếm, giới hạn, loại bỏ memento — nhưng không bao giờ mở.
- ClientNgười dùng (Ctrl+Z, nút Undo, "Revert to draft") quyết định *khi nào* quay lui; Caretaker quyết định *cái nào*.
BUG HAY GẶP: history chứa con trỏ chứ không chứa trạng thái
history[0] --+
history[1] --+--> FormEditor { title, price, variants[] }
history[2] --+ ^ cả ba "snapshot" cùng đổi theo hiện tại
SAU: ba vai, memento la goi kin ma Caretaker khong mo duoc
Caretaker (UndoManager) Originator (FormEditor)
+--------------------------+ +---------------------------+
| items: Memento[] | create| - state (private) |
| cursor: number |------>| + snapshot(): Memento |
| + push(m) / prev() /next |<------| + restore(m) |
| chi cat, khong mo |restore| + view(): string |
+------------+-------------+ +---------------------------+
| giu token kin, O(1)
v
[t1]-[p1]-[t2]-[p2] immutable, max N (ring buffer)
^ ^
oldest newest (cursor dung day)05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: undo/redo với history giới hạn 5 snapshot
type FormState = { title: string, price: number }
/** Snapshot captured BY VALUE. Nothing outside can reach in and mutate it. */
class Memento {
constructor(readonly state: Readonly<FormState>, readonly label: string) {}
}
class FormEditor {
private state: FormState = { title: '', price: 0 }
private history: Memento[] = []
private cursor = -1
constructor(private max = 5) {}
get labels() { return this.history.map(m => m.label).join(' | ') }
view() { return '"' + this.state.title + '" price=' + this.state.price }
edit(patch: Partial<FormState>, label: string) {
this.state = { ...this.state, ...patch }
this.history = this.history.slice(0, this.cursor + 1) // drop the redo branch
this.history.push(new Memento({ ...this.state }, label))
if (this.history.length > this.max) this.history.shift() // bounded memory
this.cursor = this.history.length - 1
console.log('edit ' + label + ' -> ' + this.view())
}
undo() {
if (this.cursor <= 0) return console.log('undo refused (at oldest)')
this.state = { ...this.history[--this.cursor].state }
console.log('undo -> ' + this.view())
}
redo() {
if (this.cursor >= this.history.length - 1) return console.log('redo refused (at newest)')
this.state = { ...this.history[++this.cursor].state }
console.log('redo -> ' + this.view())
}
}
const form = new FormEditor(5)
form.edit({ title: 'Ao thun' }, 't1')
form.edit({ price: 250000 }, 'p1')
form.edit({ title: 'Ao thun cotton' }, 't2')
form.undo()
form.undo()
form.redo()
form.edit({ price: 199000 }, 'p2')
console.log('kept: ' + form.labels)edit t1 -> "Ao thun" price=0 edit p1 -> "Ao thun" price=250000 edit t2 -> "Ao thun cotton" price=250000 undo -> "Ao thun" price=250000 undo -> "Ao thun" price=0 redo -> "Ao thun" price=250000 edit p2 -> "Ao thun" price=199000 kept: t1 | p1 | p2
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
- Undo/redo cho editor thật: form CMS, trang admin, canvas, rich text, bảng giá — nơi người dùng sẽ bấm Ctrl+Z và sẽ cãi với bạn nếu nó sai một bước.
- Rollback một thao tác khi phía sau lỗi: snapshot trạng thái trước khi gọi API,
restorenếu response not-ok, thay vì viết code "trừ lại tay". - Draft/autosave: "Revert to previous draft", lưu bản trước khi publish, giữ N bản gần nhất cho người dùng.
- Cấu hình/deploy:
previousConfigmột slot cũng là Memento. Bất cứ chỗ nào có "quay về bản trước" đều là họ hàng của pattern này. - Test: dựng object về một trạng thái phức tạp bằng
restore(fixtureMemento)thay vì gọi 20 method theo thứ tự. - Nhiều bước (wizard) cho phép "Quay lại bước trước" mà vẫn giữ những gì đã nhập.
Đừng dùng khi
- Lưu reference thay vì value. Bug số 1, và nó im lặng: không lỗi, chỉ undo "không ăn". Nghi ngờ ngay khi bạn thấy
push(this),push(form), hay một object lấy từ store ra rồi nhét vào history. - Copy nông cho state lồng nhau.
{ ...state }vớivariants[]cho bạn hai snapshot chia sẻ một mảng. Nếu state có bất kỳ mảng/object con nào, hoặc copy sâu có chủ đích, hoặc flatten state cho nó thành phẳng. - History không trần. SPA mở 8 tiếng + autosave 500ms = hàng trăm MB. Đặt N, cộng thêm debounce, và đo bằng
m.byteshoặc Memory tab. Undo stack của app sống lâu là memory leak có UI. - Memento giữ thứ không copy được: socket, connection DB,
FileHandle, DOM node, callback. Snapshot phải là dữ liệu thuần; resource sống thì Originator tự quản, không nằm trong gói. restore()vá một phần field → state cũ còn sót làm "bóng ma". Restore phải thay nguyên state, hoặc liệt kê tường minh mọi field. Bug này phụ thuộc thứ tự thao tác nên rất khó tái hiện.- Over-engineering: state là một object phẳng vài field, 50 bước undo?
history.push(structuredClone(state))rồipop()là xong. Đừng dựng ba class + interface cho một form 6 input. Memento đáng tiền khi state là của một class có invariant (validation trong setter) mà bạn không muốn expose.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
Vue DevTools — Vuex "Time Travel"
Tab Vuex của Vue DevTools giữ snapshot state sau mỗi mutation; bạn kéo thanh trượt, extension thay state bằng snapshot tương ứng và UI nhảy về đúng quá khứ. Caretaker (devtools) giữ hàng trăm memento mà không cần hiểu shape state — đúng tinh thần pattern.
ProseMirror / CodeMirror 6 / Monaco
Ba editor này không lưu N bản của cả tài liệu. History stack chứa step có khả năng đảo ngược: invert(step) sinh ra thao tác ngược, undo chỉ là chạy ngược step. Memento dạng diff — bộ nhớ theo kích thước thay đổi, không theo kích thước tài liệu.
Zustand temporal, redux-undo
Hai middleware này thêm undo/redo vào store bằng cách giữ mảng snapshot state giới hạn N và dịch con trỏ. Đọc source của redux-undo là đọc một Caretaker sạch sẽ, viết bằng TypeScript.
structuredClone() — primitive chụp-theo-giá-trị
Có sẵn ở Node 17+ và mọi trình duyệt hiện đại, giữ Date, Map, Set, vòng lặp. Nó là cách nhanh nhất để có snapshot an toàn, đồng thời là lời nhắc về giới hạn: ném DataCloneError ngay khi state chứa function hay DOM node, và copy toàn bộ mỗi lần gọi.
08 — Tự tay làm
Bài tập
Thêm undo cho một `Cart` (items[], coupon, note). Yêu cầu: snapshot **tối đa 5** bản, chỉ chụp **trước khi** một thao tác đổi state (không chụp mỗi lần gõ), undo bằng một hàm `undoCart()`, và khi `saveCart()` trả về lỗi thì tự restore về snapshot gần nhất.
Gợi ý, mở từng cái một:
- Viết
snapshot()trên Cart, trả về object mới do Cart tự tạo:itemsphải là mảng mới, nếu không undo sẽ thấy cả những lần push sau này. - Caretaker tách riêng: một class giữ
Memento[]+cursor, chỉ gọicart.restore(m)— không.items, không.coupon. - Với điều kiện "tự restore khi API lỗi": chụp trước khi mutate,
try { await save() } catch { cart.restore(last) }. Đừng chụp sau khi mutate.
Cart là Originator: snapshot() trả về memento bất biến chụp theo giá trị, restore(m) là đường duy nhất để mở. CartHistory là Caretaker: mảng tròn 5 phần tử, push cắt nhánh redo, prev() lùi con trỏ. Flow lưu cart: snapshot → mutate → save → nếu lỗi thì restore(prevSnapshot).
type CartState = { items: { sku: string, qty: number }[], coupon: string | null, total: number }
class CartMemento {
constructor(private readonly data: CartState) {}
unpack(): CartState { return this.data } // gọi được, nhưng không "đọc" field nào
get size() { return this.data.items.length }
}
class Cart { // Originator
private state: CartState = { items: [], coupon: null, total: 0 }
snapshot() {
return new CartMemento({ ...this.state, items: this.state.items.map(i => ({ ...i })) })
}
restore(m: CartMemento) { const d = m.unpack(); this.state = { ...d, items: d.items.map(i => ({ ...i })) } }
add(sku: string, qty = 1) { this.state.items.push({ sku, qty }) }
view() { return this.state.items.map(i => i.sku + 'x' + i.qty).join(' ') || '(trong)' }
}
class CartHistory { // Caretaker: không mở memento
private buf: CartMemento[] = []
constructor(private cart: Cart, private max = 5) {}
checkpoint() {
this.buf.push(this.cart.snapshot())
if (this.buf.length > this.max) this.buf.shift() // ring buffer, RAM có trần
}
get kept() { return this.buf.length }
undo() { const m = this.buf.pop(); if (m) this.cart.restore(m) }
}
const cart = new Cart()
const history = new CartHistory(cart, 5)
history.checkpoint(); cart.add('AO-1')
console.log(cart.view())
history.checkpoint(); cart.add('QUAN-2')
console.log(cart.view())
history.undo()
console.log('sau undo: ' + cart.view())
console.log('checkpoints giu: ' + history.kept)09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- CommandHai cách làm undo: Command cho từng thao tác tự biết `undo()`, Memento lưu nguyên trạng thái. Chúng hay đi đôi — Command giữ memento chụp trước khi chạy.
- PrototypeCả hai đều copy. Prototype copy để **nhân bản** object mới cùng hình dạng; Memento copy để **đóng băng** trạng thái, và bắt buộc bản copy phải không đổi được.
- StateMáy trạng thái cho phép quay lui thì stack trạng thái trước đó chính là Caretaker, còn memento là gói bạn nhét vào stack đó.
- ObserverSau `restore()`, thường phải phát event để UI và cache học theo trạng thái mới — nếu không, bạn có data đúng và màn hình sai.