Pattern 14/22 · Creational
Prototype Nguyên mẫu
Tạo object mới bằng cách sao chép một object mẫu có sẵn thay vì dựng lại toàn bộ cấu hình đắt đỏ — và ở JS/TS, phần khó không nằm ở chuyện "clone" mà ở clone *đúng nghĩa*: shallow hay deep, có giữ được prototype, Map/Set và vòng tham chiếu hay không.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Bạn làm trình soạn landing page. Người dùng bấm "Tạo block từ mẫu", và cái mẫu là một object config 40 field: layout, padding, animation, danh sách breakpoint, danh sách child block. Bạn viết dòng code ai cũng viết: const block = { ...template }, đổi tiêu đề, đổi padding, xong.
Tuần sau có bug: sửa padding của block mới kéo theo padding của cái template gốc. Tất cả các block tạo ra sau đó trong phiên làm việc đều inherit cái padding lỗi. Lý do: spread chỉ copy một lớp. block.style và template.style vẫn là cùng một object, nên block.style.padding = 24 là viết vào object chung. Trên production, thứ config đó được lưu xuống DB và thành 300 trang hỏng.
Bạn "sửa" bằng JSON.parse(JSON.stringify(template)). Nó chạy, và nó âm thầm phá ba thứ: Date thành string, Map/Set thành {}, mọi function (kể cả method của class) bốc hơi, undefined bị xoá key. UI nhận được một object "trông giống" template: typeof block.publishedAt === "string" nên .getTime() nổ; hoặc instanceof BlockConfig === false nên block.getLabel() undefined giữa chừng. TypeScript không báo, vì JSON.parse trả về any.
Rồi tới vòng tham chiếu. Tree node của bạn có parent trỏ ngược lên cha, một cấu trúc hoàn toàn bình thường. JSON.stringify(node) nổ "Converting circular structure to JSON", và phản xạ tự nhiên là... bỏ con trỏ parent đi để JSON chạy — biến một graph thành tree, rồi vài module khác bắt đầu tự dựng lại quan hệ cha-con bằng tay, mỗi nơi một kiểu.
Vấn đề lớn lên theo dự án: mỗi tính năng tự chế một cách copy riêng ({...o}, lodash cloneDeep, JSON round-trip, toRaw() của Vue rồi tự clone tay). Không ai quyết định một lần object này được copy như thế nào. Kết quả là cùng một template, ba chỗ copy ra ba độ sâu khác nhau, và bug tái xuất hiện mỗi khi ai đó thêm một field lồng nhau.
02 — Ý tưởng, chưa động vào code
Giải pháp
Prototype nói: hãy để object tự biết sao chép chính nó. Thay vì người ngoài đoán cấu trúc bên trong rồi copy thủ công, chính class khai báo một method clone() — nó biết field nào là primitive, field nào phải tạo object mới, field nào là tài nguyên dùng chung và không được copy (connection, handle, DOM node).
Ở TS/JS, clone() ít khi cần tới thuật toán phức tạp; cái nó thực sự mua cho bạn là một chỗ duy nhất, có tên, để quyết định deep hay shallow. Một quyết định được đặt tên thì review được, test được, và sửa một lần. Ngược lại, {...x} rải ở 40 điểm gọi là 40 quyết định ngầm, mỗi lần thêm field lồng nhau là thêm một cái bug tiềm năng.
Chọn công cụ theo nội dung của object: toàn primitive và field phẳng thì spread là đủ, đừng nghi ngờ. Cây dữ liệu thuần (plain data) thì structuredClone() — deep copy thật, đi được qua vòng tham chiếu, giữ Date/Map/Set/ArrayBuffer, nhưng mất function và mất prototype. Instance của class có method thì phải tự viết clone() (gọi constructor với dữ liệu đã copy), hoặc serialize có kiểm soát (schema + zod, superjson). Prototype không bắt bạn chọn một trong ba — nó bắt bạn chọn có ý thức và chọn ngay trên class.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Tìm đúng đối tượng: thứ gì dựng lại tốn kém
Prototype không dành cho object 3 field tạo bằng new. Nó dành cho object mà "bản gốc" tích luỹ kết quả của một quá trình đắt: đọc từ DB, parse một file cấu hình, build cây breakpoint, suy ra default từ theme, hoặc chính tay designer cấu hình 40 tham số.
Dấu hiệu nhận diện trong code: một hàm createDefault...() / getTemplate...() được gọi rồi bị mutate ngay sau đó ở nơi gọi. Chỗ mutate đó chính là nơi cần clone(), vì template là tài sản dùng chung.
const template = await loadBlockTemplate('hero-v3') // 12 DB query + parse
const block = template
block.style.padding = 24 // <- đang sửa trực tiếp trên template!
block.title = 'Khuyến mãi Tết'
await save(block)Nói rõ: copy hay "thiết lập lại từ đầu"
Có hai cách cho ra một object giống hệt: chạy lại toàn bộ quá trình khởi tạo (loadBlockTemplate() lần nữa), hoặc copy object đang có. Cách thứ nhất độc lập với trạng thái hiện tại của mẫu — nếu config vừa bị user sửa trong bộ nhớ, bạn mất nó.
Khi mẫu nằm trong cache/bộ nhớ và bạn cần bản sao của đúng phiên bản đó, chỉ có copy. Khi mẫu là hàm thuần, deterministic, rẻ: gọi lại hàm là đủ và trung thực hơn. Đừng viết clone() để rồi trong lòng nó gọi lại load() — đó là Factory Method đội lốt, và nó chậm hơn clone.
// A. Dựng lại: an toàn nhưng bỏ mất trạng thái hiện tại của mẫu
const block1 = await loadBlockTemplate('hero-v3')
// B. Copy từ object đang sống trong memory: giữ nguyên mọi sửa đổi
const block2 = block.clone()Shallow copy: spread và Object.assign chỉ đi một lớp
{...o}, Object.assign({}, o), structuredClone chưa hề xuất hiện: cả hai bản spread đều chỉ tạo object mới ở tầng ngoài cùng. Mọi giá trị tham chiếu (object, array, Map, Date, function) được copy con trỏ.
Cái bẫy là nó đúng 90% số lần, và 10% còn lại là data corruption không exception. Rule of thumb: spread chỉ an toàn khi object flat.
const template = { id: 'hero-v3', tags: ['hero'], style: { pad: 8 } }
const a = { ...template } // spread
const b = Object.assign({}, template)
const c = structuredClone(template) // deep, để so sánh
a.tags.push('a'); a.style.pad = 99
b.style.pad = 42
console.log(template.tags.join('+'), template.style.pad)
console.log(c.tags.join('+'), c.style.pad)hero+a 42 hero 8
JSON round-trip: cái bẫy tiện lợi
JSON.parse(JSON.stringify(x)) là deep copy... với điều kiện object của bạn chỉ chứa thứ mà JSON mô tả được. Nó phá huỷ có chọn lọc: Map/Set → {}, function → bị bỏ qua, undefined → mất key, Date → string ISO, BigInt → nổ, và đồ thị có chu trình → nổ "Converting circular structure to JSON".
Tệ nhất là hậu quả không tới ngay: object trả về vẫn "trông giống" nên nó chui lọt qua UI, rồi 3 tầng gọi sau mới nổ, hoặc không nổ mà lưu xuống DB một giá trị sai. Và vì JSON.parse trả any, TypeScript đứng ngoài cuộc.
class BlockConfig {
constructor(public title: string, public at: Date, public meta: Map<string, number>) {}
label() { return this.title + ' @ ' + this.at.toISOString() }
}
const orig = new BlockConfig('hero', new Date(0), new Map([['v', 3]]))
const copy: any = JSON.parse(JSON.stringify(orig))
console.log('at:', typeof copy.at, '| meta:', JSON.stringify(copy.meta))
console.log('label:', typeof copy.label, '| instanceof:', copy instanceof BlockConfig)
const node: any = { name: 'root', children: [] }
node.children.push(node)
try { JSON.stringify(node) }
catch (e) { console.log('circular ->', (e as Error).name) }at: string | meta: {}
label: undefined | instanceof: false
circular -> TypeErrorDate, Map, Set, BigInt, function, hoặc class instance: JSON round-trip không phải deep copy, nó là mất dữ liệu.structuredClone: deep copy tử tế, nhưng không phải cho class
structuredClone() (Node 17+, Bun, trình duyệt hiện đại, globalThis) dùng structured clone algorithm — cùng thuật toán mà postMessage dùng để gửi dữ liệu qua Worker. Nó deep, nó đi được qua vòng tham chiếu mà vẫn bảo toàn quan hệ (hai con trỏ cùng chỉ một object thì sau khi clone vẫn cùng chỉ một object), và nó giữ Date, Map, Set, RegExp, ArrayBuffer, Error.
Cái giá: nó làm việc theo danh sách loại được phép, không theo prototype. Function → DataCloneError. Proxy → DataCloneError (object reactive()/ref() của Vue, store của MobX, mock của Vitest đều là Proxy). Instance của class thì clone thành plain object: data còn, instanceof và method mất.
const tree: any = { name: 'root', children: [] }
tree.parent = null
tree.children.push(tree)
const cloned = structuredClone(tree)
console.log('deep:', cloned.children[0] === cloned) // chu trình giữ nguyên
console.log('isolated:', cloned.children[0].children === tree.children)
const reactiveLike = new Proxy({ a: 1 }, {})
try { structuredClone(reactiveLike) }
catch (e) { console.log('proxy ->', (e as Error).name) }
class K { constructor(public n = 1) {} m() { return 'm' } }
const ck: any = structuredClone(new K())
console.log('class ->', ck instanceof K, typeof ck.m, JSON.stringify(ck))deep: true
isolated: false
proxy -> DataCloneError
class -> false undefined {"n":1}structuredClone copy dữ liệu, không copy hành vi. Object của bạn có method không? Nếu có, nó không thuộc về structuredClone.Cho object tự clone: đây mới là Prototype
Bây giờ quay lại GoF: một interface clone() và mỗi class tự triển khai. Trong TS, interface Cloneable<T> là đủ. clone() gọi constructor (không copy prototype tay), nên kết quả luôn là instance đúng loại, instanceof đúng, method còn nguyên.
Điểm mấu chốt nằm trong thân clone(): bạn liệt kê tường minh field nào cần tạo object mới, field nào giữ nguyên tham chiếu. Đây là lúc quyết định "deep tới đâu" được viết ra một lần, có tên, có code review, thay vì âm thầm tái quyết định ở mọi điểm gọi.
interface Cloneable<T> { clone(): T }
class BlockConfig implements Cloneable<BlockConfig> {
constructor(
readonly title: string,
readonly tags: string[],
readonly style: { pad: number, bg: string },
readonly publishedAt: Date,
readonly meta: Map<string, number>,
) {}
label() { return this.title + ' [' + this.tags.join('+') + ']' }
clone(): BlockConfig {
return new BlockConfig(
this.title,
[...this.tags], // array: tạo cái mới
{ ...this.style }, // object phẳng: shallow là đủ
new Date(this.publishedAt.getTime()), // Date: tạo cái mới
new Map(this.meta), // Map: constructor copy
)
}
}
const a = new BlockConfig('hero', ['hero'], { pad: 8, bg: '#fff' }, new Date(0), new Map([['v', 1]]))
const b = a.clone()
b.tags.push('tet'); b.style.pad = 24; b.meta.set('v', 2)
console.log(a.label(), a.style.pad, a.meta.get('v'))
console.log(b.label(), b.style.pad, b.meta.get('v'))
console.log('đúng loại:', b instanceof BlockConfig)hero [hero] 8 1 hero [hero+tet] 24 2 đúng loại: true
clone() là bản thiết kế của object: nó nói field nào sở hữu, field nào tham chiếu. Đọc 15 dòng đó hiểu semantic của cả class.Clone đồ thị có trỏ ngược: cần memo Map
Tree node có parent, graph có cạnh hai chiều, danh sách item cùng trỏ về một object shared. Deep copy naive theo kiểu "clone() gọi clone() của con" sẽ lặp vô hạn — hoặc tinh vi hơn, phình to: cùng một object con bị clone hai lần thành hai bản thể khác nhau, và a.children[0].owner === b.owner thành false.
Thuốc giải: một Map<object, object> memo sống suốt một lần clone. "Object gốc này đã bản sao chưa? Có thì trả về cái cũ." Đây chính xác là cách structuredClone giữ được tính nhất quán của đồ thị.
function deepClone<T>(root: T): T {
const seen = new Map<unknown, unknown>()
const copy = (n: any): any => {
if (n === null || typeof n !== 'object') return n
const hit = seen.get(n)
if (hit) return hit // đã copy -> dùng lại, giữ quan hệ
if (Array.isArray(n)) {
const arr: any[] = []
seen.set(n, arr) // đăng ký TRƯỚC khi đệ quy
arr.push(...n.map(copy))
return arr
}
const out: any = {}
seen.set(n, out) // đăng ký TRƯỚC khi đệ quy
for (const k of Object.keys(n)) out[k] = copy(n[k])
return out
}
return copy(root) as T
}
const sharedTheme = { primary: '#f60' } // object DÙNG CHUNG, không thuộc về node nào
const root: any = { name: 'root', theme: sharedTheme, parent: null, children: [] }
const child: any = { name: 'child', theme: sharedTheme, parent: root, children: [root] }
root.children.push(child)
const c = deepClone(root)
console.log('cycle :', c.children[0].children[0] === c)
console.log('parent :', c.children[0].parent === c)
console.log('identity:', c.theme === c.children[0].theme, '| tách khỏi gốc:', c.theme !== sharedTheme)cycle : true parent : true identity: true | tách khỏi gốc: true
seen.set trước khi đệ quy là chi tiết sống còn: ghi sau thì chu trình làm stack overflow. Và object shared chỉ bị clone MỘT lần, nên quan hệ dùng chung còn nguyên.Ràng buộc bằng type, rồi test thật một lần
Ép mọi object dùng làm mẫu phải khai báo clone() qua interface Cloneable<T>. Nhờ vậy không còn chỗ nào gọi JSON.parse(JSON.stringify(x)) lên một object "có thể có method": bạn không thể clone thứ chưa tuyên bố cách clone của nó.
Và hãy test bằng đúng cái sẽ hỏng: đổi một field lồng nhau của bản clone rồi assert object gốc không đổi. Thêm một field lồng mới mà quên sửa clone() thì test này bắt ngay — đó là toàn bộ giá trị của pattern, được chốt lại bằng 6 dòng test.
interface Cloneable<T> { clone(): T }
class BlockConfig implements Cloneable<BlockConfig> {
constructor(
readonly title: string,
readonly tags: string[],
readonly style: { pad: number, bg: string },
readonly publishedAt: Date,
readonly meta: Map<string, number>,
) {}
clone(): BlockConfig {
return new BlockConfig(
this.title, [...this.tags], { ...this.style },
new Date(this.publishedAt.getTime()), new Map(this.meta),
)
}
}
const original = new BlockConfig('hero', ['hero'], { pad: 8, bg: '#fff' }, new Date(0), new Map([['v', 1]]))
const draft = original.clone()
draft.style.pad = 24 // chỉ được ảnh hưởng tới draft
draft.tags.push('tet')
draft.meta.set('v', 9)
console.log('gốc sau khi sửa draft:', original.style.pad, original.tags.join('+'), original.meta.get('v'))
// Guard: thứ gì dùng làm template thì BẮT BUỘC khai báo cách clone
function asTemplate(x: Cloneable<unknown>): void { void x }
asTemplate(original)gốc sau khi sửa draft: 8 hero 1
clone() chỉ là một cái tên đẹp cho một bug chưa tới.04 — Ai nói chuyện với ai
Cấu trúc
- PrototypeHợp đồng tự sao chép: `clone(): this`. Trong TS thường là `interface Cloneable<T>`.
- ConcretePrototypeClass cụ thể, triển khai `clone()` bằng cách gọi constructor của chính nó với dữ liệu đã copy đúng độ sâu.
- ClientCần một object giống mẫu. Chỉ gọi `template.clone()`, không cần biết mẫu có bao nhiêu field lồng nhau.
- PrototypeStoreNơi chứa các mẫu đã dựng sẵn, tra theo key: template, preset, plan tier, theme. Kết hợp với registry/factory.
- ClonerChiến lược copy (spread, structuredClone, serialize theo schema, clone graph có memo). Chọn theo nội dung object, đặt ở một chỗ.
Client
│ template.clone()
▼
┌───────────────────────────┐ ┌─────────────────────────┐
│ Prototype (Cloneable<T>) │ ◄───│ PrototypeStore │
│ + clone(): T │ │ 'hero-v3' → template │
└─────────────┬─────────────┘ │ 'card' → template │
│ implement └─────────────────────────┘
▼
┌───────────────────────────────────────────────┐
│ ConcretePrototype (BlockConfig) │
│ + clone() ──► new BlockConfig( │
│ [...tags], { ...style }, │
│ new Date(at), new Map(meta)) │
│ quyết định DEEP TỚI ĐÂU, ở đây, một lần │
└───────────────┬───────────────────────────────┘
│ dùng khi cần
┌────────┴─────────┐
▼ ▼
spread 1 lớp structuredClone
(object phẳng) (data thuần, có cycle)
✗ function, ✗ Proxy,
✗ prototype của class05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: bốn cách copy, bốn kết quả khác nhau
class Widget {
constructor(public id: string, public tags: string[], public style: { pad: number }) {}
label() { return this.id + '/pad=' + this.style.pad }
}
const base = new Widget('base', ['header'], { pad: 8 })
// 1) Shallow: object MỚI nhưng field nested vẫn chung tham chiếu
const shallow = { ...base }
shallow.tags.push('sidebar')
shallow.style.pad = 99
console.log('1 shallow :', base.tags.join('+'), '| base.style.pad =', base.style.pad)
// 2) JSON round-trip: method bay màu, prototype chain bay màu
const plain = JSON.parse(JSON.stringify(base))
console.log('2 json : label =', typeof plain.label, '| instanceof Widget =', plain instanceof Widget)
const cfg = { cache: new Map([['a', 1]]), hook: () => 1, empty: undefined }
const jsonCfg = JSON.parse(JSON.stringify(cfg))
console.log('3 json lossy : cache =', JSON.stringify(jsonCfg.cache), '| hook =', typeof jsonCfg.hook, '| empty còn =', ('empty' in jsonCfg))
// 3) Circular: JSON nổ, structuredClone sống, giữ nguyên đồ thị
const node: any = { name: 'root', children: [] }
node.children.push(node)
try { JSON.stringify(node) }
catch (e) { console.log('4 json throws:', (e as Error).name) }
const clonedNode = structuredClone(node)
console.log('5 clone ok : self-ref =', clonedNode.children[0].children === clonedNode.children)
// 4) clone() tự viết: deep copy mà vẫn đúng class
class CloneableWidget {
constructor(public id: string, public tags: string[], public style: { pad: number }) {}
clone(): CloneableWidget { return new CloneableWidget(this.id, [...this.tags], { ...this.style }) }
}
const w = new CloneableWidget('w', ['a'], { pad: 4 })
const w2 = w.clone()
w2.tags.push('b')
console.log('6 clone() : đúng class =', w2 instanceof CloneableWidget, '|', w.tags.join('+'), 'vs', w2.tags.join('+'))1 shallow : header+sidebar | base.style.pad = 99
2 json : label = undefined | instanceof Widget = false
3 json lossy : cache = {} | hook = undefined | empty còn = false
4 json throws: TypeError
5 clone ok : self-ref = true
6 clone() : đúng class = true | a vs a+bCù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 "mẫu" dựng tốn kém (nhiều DB query, parse, suy default) và bạn cần nhiều bản sao lệch nhau vài field. Đây là trường hợp gốc của pattern.
- Preset / theme / plan tier / template market: bộ cấu hình đã được duyệt, user chỉ sửa một phần nhỏ.
- Cần snapshot để so sánh hoặc undo: giữ bản gốc trong bộ nhớ rồi diff với bản clone đã sửa (đi cặp với Memento).
- Object có nhiều field lồng nhau và bạn muốn quyết định độ sâu copy một lần trên class, không phải ở từng điểm gọi.
- Graph/tree có tham chiếu ngược hoặc nhiều con trỏ cùng chỉ một node: clone đúng semantic cần memo — càng phải tập trung vào một chỗ.
- Ngược lại, object flat toàn primitive:
{...o}là lựa chọn đúng và đừng thêm tầng nào.
Đừng dùng khi
- Shallow khi cần deep — bug thật, im lặng, và lan xuống DB. Spread và
Object.assignchỉ thay đổi tầng ngoài cùng; một field array/object mới được thêm là đủ để tái phát. JSON.parse(JSON.stringify())phá dữ liệu có chọn lọc và không báo lỗi: Date→string, Map/Set→{}, function bị bỏ, undefined mất key, BigInt và cycle thì ném exception. Nó cũng trảany, nên type checker không cứu bạn.structuredClonetừ chốifunctionvàProxy(DataCloneError), và clone class instance mất prototype: data còn,instanceofsai, method undefined. Đem store/actions sang Worker bằng postMessage là gặp ngay. Cần giữ hành vi thì phải tự viếtclone().Object.freeze(obj)chỉ đóng băng tầng ngoài; field lồng vẫn sửa được, nên "template đã freeze, an toàn rồi" là một cảm giác sai. Muốn đóng băng thật phải đệ quy, và lúc đó bạn nên dùngas const+ clone khi dùng.- Over-engineering: object 4 field, không nested, không vòng. Viết
clone()40 dòng cho nó là bịa ra chi phí. Prototype đáng giá khi việc tái khởi tạo đắt, hoặc khi object đã nested/graph tới mức không ai copy đúng bằng mắt. - Clone không phải immutable. Copy-on-write tốt hơn clone-sau-mutate khi object lớn: dùng
readonly/as constở hợp đồng và chỉ clone khi thực sự phân nhánh, nếu không bạn trả giá copy ở mọi lần đọc.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
DOM: node.cloneNode(deep)
Ví dụ Prototype thuần tuý nhất trên browser: một node tự biết sao chép chính nó, tham số deep chính là câu hỏi "copy tới đâu". Lưu ý nó không copy listener đăng ký bằng addEventListener và không copy state của form — cùng lesson: clone hình thức không phải clone hành vi.
postMessage / Web Worker / worker_threads
Gửi dữ liệu qua lại giữa thread dùng structured clone algorithm: deep, giữ Date/Map/ArrayBuffer/cycle, nhưng gửi function sang Worker thì nhận DataCloneError. Đây là lý do mọi API Worker đều nhận dữ liệu mô tả công việc (message) chứ không nhận callback.
structuredClone() global (Node 17+, Bun, browser)
Một hàm global, không import, deep copy data thuần. Vue/Nuxt: object từ reactive()/ref() là Proxy nên structuredClone bắn DataCloneError — phải toRaw() trước, và nếu object đó có action thì vẫn không clone được: bạn chỉ clone được data, không clone được store.
Clipboard/draft trong Vue/Nuxt
Lưu draft form rồi "Reset về bản gốc": pattern phổ biến là snapshot một lần (structuredClone(toRaw(form)) hoặc clone theo schema) rồi restore. Snapshot sai độ sâu = reset chỉ hoàn nguyên được field tầng một, user thấy form "không reset hết".
Immutable store (Redux, Pinia, TanStack Query)
Các store hiện đại tránh deep clone bằng structural sharing: object không đổi giữ nguyên tham chiếu, chỉ đường dẫn tới phần thay đổi được tạo mới ({...state, user: {...state.user, name}}). Nếu bạn deep clone toàn bộ state trong một selector/reducer, bạn vừa tự phá vỡ reference equality và làm UI re-render cả cây.
08 — Tự tay làm
Bài tập
Cho `type Node = { name: string, owner: { id: string }, parent: Node | null, children: Node[] }` (con trỏ `parent` tạo chu trình). a) Viết `deepCopyNaive(n)` copy đệ quy không memo rồi gọi trên một cây có 2 node cùng trỏ về **một** object owner dùng chung; chỉ ra chỗ nào sai. b) Viết `cloneTree(n)` đúng: không lặp vô hạn, owner shared vẫn là **một** object, `parent` trỏ vào node thuộc bản clone chứ không phải bản gốc.
Gợi ý, mở từng cái một:
- Không memo thì chu trình khiến đệ quy không dừng — bạn cần chặn ở đâu? Ghi
seen.settrước hay sau khi đệ quy con? - Vật shared (owner) và vật thuộc về node (children) phải xử lý khác nhau: một cái dùng Map để dùng lại, một cái tạo mới.
- Sau khi clone xong, test bằng ba assert:
c.children[0].parent === c,c.children[0].owner === c.children[1].owner,c.children[0].owner !== gốc.children[0].owner(nếu owner được copy) — hoặc===nếu bạn cố tình share owner. Hãy chọn rồi viết test cho lựa chọn đó.
Hai phần: một Map để chặn cycle và tái sử dụng bản sao của object shared, và quy tắc "đăng ký bản sao trước khi đệ quy". Với owner, quyết định share hay copy là nghiệp vụ: nếu owner là thực thể dùng chung (user, tenant) thì giữ nguyên tham chiếu sang object gốc; nếu owner thuộc về node thì copy qua cùng Map. Đừng quên field lồng đơn giản (owner: { ...n.owner }) cũng là một quyết định cần viết ra.
type Node = { name: string, owner: { id: string }, parent: Node | null, children: Node[] }
// owner là thực thể dùng chung: GIỮ nguyên tham chiếu (không copy)
function cloneTree(root: Node): Node {
const seen = new Map<Node, Node>()
const copy = (n: Node): Node => {
const hit = seen.get(n)
if (hit) return hit
const out: Node = { name: n.name, owner: n.owner, parent: null, children: [] }
seen.set(n, out)
out.parent = n.parent ? copy(n.parent) : null
out.children = n.children.map(copy)
return out
}
return copy(root)
}
const owner = { id: 'u1' }
const root: Node = { name: 'root', owner, parent: null, children: [] }
const a: Node = { name: 'a', owner, parent: root, children: [root] }
const b: Node = { name: 'b', owner, parent: root, children: [] }
root.children.push(a, b)
const c = cloneTree(root)
console.log(c.children[0].parent === c) // true
console.log(c.children[0].children[0] === c) // cycle, true
console.log(c.children[0].owner === c.children[1].owner) // shared, true
console.log(c.children[0].owner !== c.children[0].parent) // không lẫn type, true09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- Abstract FactoryCùng họ creational: Abstract Factory dựng object từ **công thức**, Prototype dựng object từ **một bản mẫu đã sống**. Khi "công thức" quá dài và chủ yếu là default, Prototype rẻ hơn.
- BuilderBuilder cũng bắt đầu từ cấu hình nhiều bước, nhưng nó produce object *hợp lệ theo trình tự*. Prototype produce object *giống hệt*, kể cả bản đang dở. Template + mutate = Prototype; dựng từng bước + validate = Builder.
- MementoMemento **là** một snapshot để restore — và snapshot chỉ đáng tin khi copy đúng độ sâu. Prototype là cách lấy snapshot, Memento là lý do bạn lấy nó (undo, rollback, draft).
- CompositeComposite là cây node lồng nhau; clone một composite bắt buộc phải đệ quy và xử lý tham chiếu cha-con. Đây là nơi shallow copy lộ lỗi nhanh nhất.