Pattern 07/22 · Behavioral
Iterator Bộ lặp
Duyệt một collection mà không lộ nó được lưu bằng gì: mảng, map, cây hay trang dữ liệu remote. Bên ngoài chỉ thấy `next()` trả `{ value, done }`, và `for...of` chạy trên đúng hợp đồng đó.
01 — Mở đầu bằng code đang hỏng
Vấn đề
App Nuxt của bạn giữ cây component dạng { value, children? }. Trang cây thư mục cần liệt kê: function walk(nodes) { for (const n of nodes) { render(n); walk(n.children ?? []) } }. Xong trong năm phút, chạy tốt.
Rồi cần "tìm node đầu tiên tên Modal.vue". walk không cho bạn dừng giữa đường — nó duyệt hết. Nên bạn copy nguyên vòng lặp, sửa thành if (found) return. Tiếp theo: "5 node đầu", "duyệt theo chiều rộng", "bỏ qua node đang bị collapsed", "duyệt để serialize nhưng đừng vào node_modules". Mỗi yêu cầu là một bản copy của cùng vòng lặp, và mỗi bản sai một kiểu khác nhau — bản thì thiếu node cuối, bản thì vào vô hạn nếu cây có cycle.
Rồi collection không còn là cây thuần: 200 node đầu nằm trong memory, phần còn lại fetch theo trang. Vòng lặp giờ phải vừa await vừa nhớ "đang ở node nào, trang mấy, con trỏ gì". Logic duyệt và logic lấy dữ liệu dính thành một búi, và đổi API là sập cả sáu chỗ copy.
Kẻ thù thầm lặng: code bên ngoài đã biết quá nhiều. Nó biết children là mảng, biết field tên là value, biết node gốc nằm ở state.nodes. Ngày bạn đổi children?: Node[] thành children: Map<string, Node> — một thay đổi hoàn toàn nội bộ — bạn phải sửa chín chỗ rải rác trong UI, mỗi chỗ một kiểu indexing khác nhau.
Cái duy nhất thực sự thay đổi là cách đi từ phần tử này tới phần tử kế tiếp. Chain of Responsibility sẽ nói "ai xử lý"; ở đây câu hỏi là "cái kế tiếp là cái nào" — và câu trả lời đó nên nằm một chỗ, sau một hợp đồng nhỏ.
02 — Ý tưởng, chưa động vào code
Giải pháp
Tách "duyệt như thế nào" khỏi "ai đang duyệt". Iterator là một object nhỏ, có state, và có đúng một method: next() trả { value, done }. Nó tự nhớ mình đang ở đâu. Collection chỉ việc cung cấp iterator, không ai được phép biết nó chứa gì bên trong.
JavaScript đã định nghĩa sẵn hợp đồng này, bạn không phải tự chế: một object có method Symbol.iterator() là iterable; thứ nó trả về (có next()) là iterator. for...of, spread [...x], Array.from, destructuring, yield*, new Map(pairs) tất cả chỉ dùng đúng hai thứ đó. Nghĩa là iterator bạn viết hôm nay chạy được trong mọi syntax của ngôn ngữ, không cần API riêng.
Hai tính chất đáng tiền. Có state: xin hai iterator từ cùng một collection cho hai vòng lặp chạy song song, chúng không giẫm nhau. Lười (lazy): giá trị chỉ được sinh ra khi người gọi thực sự hỏi — đúng thứ pagination cần, vì bạn không muốn fetch 10.000 dòng chỉ để hiển thị 20 dòng và để user bấm ESC.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Viết bản "lộ hết nội bộ" trước
Bản này không sai, nó chỉ phẳng theo cấu trúc dữ liệu. Mỗi lần cấu trúc đổi, mọi chỗ copy đều phải đổi theo. Đó là thứ ta sắp bỏ.
Để ý find không thể dừng sớm: nó phải gọi walk và walk thì duyệt hết. Cái thiếu không phải điều kiện if, mà là khả năng tạm dừng.
type Tree = { value: string, children?: Tree[] }
// Lộ cấu trúc: caller phải biết children là array, value là field gì
function walk(nodes: Tree[], visit: (v: string) => void) {
for (const n of nodes) {
visit(n.value)
walk(n.children ?? [], visit)
}
}
// Muốn dừng sớm? Copy nguyên loop, sửa một dòng.
function findFirst(nodes: Tree[], want: string): string | null {
for (const n of nodes) {
if (n.value === want) return n.value
const hit = findFirst(n.children ?? [], want)
if (hit) return hit
}
return null
}Hai khái niệm: iterable là nơi XIN, iterator là CHÍNH lượt duyệt
Cái khiến người ta vấp là tưởng hai thứ là một. Iterable không có state: nó chỉ có Symbol.iterator() để xin một lượt duyệt mới. Iterator thì có state: nó là con trỏ đang chạy. Gọi Symbol.iterator() hai lần trên cùng một mảng, bạn được hai iterator độc lập — đó là lý do hai vòng lặp lồng nhau hoạt động.
Iterator là one-shot: đi tới done: true rồi thì hết, không tự reset. Muốn duyệt lại, xin iterator mới (tức là for...of lại, vì for...of tự gọi Symbol.iterator()).
interface Iterable<T> {
[Symbol.iterator](): Iterator<T> // xin một lượt duyệt
}
interface Iterator<T> {
next(): IteratorResult<T> // { value, done: false } | { value, done: true }
return?(value?: T): IteratorResult<T> // đóng sớm: break/throw gọi nó
}
// Object thường KHÔNG iterable: for...of {} sẽ throw.
// Object.keys/values/entries sinh ra mảng iterable -> cầu nối chính thức.Generator: viết như vòng lặp thường, nhận về cả iterator lẫn iterable
function* là cách rẻ nhất để có iterator đúng chuẩn: bạn viết đệ quy như bình thường, yield đánh dấu điểm tạm dừng, và engine tự lưu toàn bộ state (con trỏ stack, biến cục bộ) hộ bạn. yield* uỷ quyền cho iterator khác — đó là cách đệ quy hoạt động mà không cần tự quản lý stack.
Một generator object vừa là iterator (có next()) vừa là iterable (gen[Symbol.iterator]() trả về chính nó). Vì vậy nó chui được vào for...of, spread, Array.from, và yield* của generator khác.
function* walk(node: Tree): Generator<string> {
yield node.value // tạm dừng ngay đây
for (const child of node.children ?? [])
yield* walk(child) // uỷ quyền cho lượt duyệt của cây con
}
for (const v of walk(root)) {
if (v === 'Modal.vue') break // dừng sớm: không tính tiếp phần sau
}
;[...walk(root)] // spread cũng chỉ lấy cái nó cầnIterator thủ công: `stack` chính là state của nó
Khi state phức tạp hơn "một con trỏ mảng" — cây, đồ thị, nhiều nguồn nối tiếp, con trỏ remote — bạn tự viết next(). Toàn bộ bí thuật nằm ở chỗ state nằm trong closure, không nằm ngoài: mỗi lần gọi next(), iterator tự biết mình đang ở đâu.
Chi tiết dễ sai: khi push children vào stack thì push ngược thứ tự, vì stack LIFO — nếu không, anh cả sẽ bị duyệt cuối cùng và thứ tự cây của bạn lộn xộn một cách rất khó chịu.
Dòng [Symbol.iterator]() { return this } biến iterator thành iterable, để nó dùng được với for...of và spread. Đây chính xác là cách generator object hành xử.
let touched = 0
function preorder(root: Tree) {
const stack: Tree[] = [root] // <- state: chưa ai thấy node nào
return {
next(): IteratorResult<string> {
const node = stack.pop()
if (!node) return { value: '', done: true }
touched++
for (const c of (node.children ?? []).slice().reverse()) stack.push(c)
return { value: node.value, done: false }
},
[Symbol.iterator]() { return this }, // iterator cũng là iterable
}
}index ra ngoài thành biến module, hai vòng lặp song song sẽ đi lẫn vào nhau.Chạy thử: lazy, và "duyệt tiếp từ chỗ đang dừng"
Ba dòng dưới chứng minh cả hai tính chất. Dòng 2: lấy 3 node đầu và break — biến touched cho thấy iterator chạm đúng 3 node, không phải 7. Không ai trả giá cho phần user không xem.
Dòng 3: cùng iterator đó, break rồi trải tiếp — nó đi tiếp từ chỗ đang đứng, không quay lại đầu. Đó là "có state". Muốn quay lại đầu thì gọi preorder(tree) lần nữa, tức là xin lượt duyệt mới.
console.log('generator : ' + [...walk(tree)].join(' > '))
const it = preorder(tree)
const first3: string[] = []
for (const v of it) {
first3.push(v)
if (first3.length === 3) break
}
console.log('3 node đầu: ' + first3.join(' > ') + ' (chạm ' + touched + '/7 node)')
console.log('duyet tiếp: ' + [...it].join(' > '))generator : app > components > Button.vue > Modal.vue > pages > index.vue > nuxt.config.ts 3 node đầu: app > components > Button.vue (chạm 3/7 node) duyet tiếp: Modal.vue > pages > index.vue > nuxt.config.ts
Lười đúng nghĩa: pagination bằng con trỏ trang
Đây là chỗ Iterator kiếm được cơm. Một generator trang chỉ chạy thân của nó (tức là gọi API) khi người gọi thực sự kéo giá trị. User xem ba trang thì đúng ba trang được fetch, không phải 50. break không phải "bỏ qua hiển thị" — nó không chi tiền.
Cùng hình dạng đó dùng cho cursor API: next() gọi fetch(url + cursor) rồi lấy cursor từ response. Nếu hết dữ liệu, return — done: true, và loop kết thúc mà không cần biết tổng số trang.
let fetched = 0
function* pages(pageSize: number, total: number): Generator<number> {
for (let p = 1; p * pageSize <= total; p++) {
fetched++ // chỉ chạy khi người gọi thực sự hỏi
yield p * pageSize // "đã có trong tay p*pageSize item"
}
}
const feed = pages(20, 1000)
let have = 0
for (const got of feed) {
have = got
if (have >= 60) break // không trả tiền cho trang thứ 4
}
console.log(have + ' item, ' + fetched + ' trang')60 item, 3 trang
Array.map/filter trả về mọi phần tử ngay. Iterator trả về một phần tử khi được hỏi. Với dữ liệu lớn hoặc remote, hai chữ "khi được hỏi" là toàn bộ giá trị.Ghép pipeline: BFS, filter, map — mỗi cái một iterator, lồng được
Vì mỗi bước đều là iterable, bạn ghép chúng: filter(bfs(root), n => n.depth > 1) là một lượt duyệt theo chiều rộng, chỉ lấy node sâu, và vẫn lazy từ đầu tới cuối. Không mảng trung gian nào được tạo. Đây là phiên bản thủ công của pipeline Observable/iterator-helpers.
Chú ý yield* delegate cho mọi thứ có [Symbol.iterator], nên generator của bạn ăn vào generator khác, Map, Set, NodeList... mà không cần biết loại nào.
function* bfs(root: Tree): Generator<string> {
const queue: Tree[] = [root]
while (queue.length > 0) {
const n = queue.shift()!
yield n.value
queue.push(...(n.children ?? [])) // FIFO -> cùng tầng trước
}
}
function* filter<T>(source: Iterable<T>, keep: (x: T) => boolean): Generator<T> {
for (const x of source) if (keep(x)) yield x
}
for (const v of filter(bfs(root), x => x.endsWith('.vue'))) {
console.log(v) // đọc như mô tả, vẫn chạy từng cái một
}Cạm bẫy của state: hết là hết, và `break` có cleanup
Iterator không tự reset. [...it] lần thứ hai trả về mảng rỗng. Đây không phải bug của engine — đó là định nghĩa. Nếu bạn cần duyệt lại, xin iterator mới; và nếu bạn viết cache trả về cùng một iterator cho mọi lần gọi, hai vòng lặp lồng nhau sẽ ăn cắp vị trí của nhau.
Điều ngược lại thì nhiều người không biết: break/throw trong for...of khiến engine gọi iterator.return() nếu nó có. Với generator, điều đó chạy finally ngay lập tức — nghĩa là function* là chỗ an toàn để đóng connection, nhả lock, huỷ subscription.
const it = [1, 2, 3][Symbol.iterator]()
console.log([...it].join(','), JSON.stringify([...it])) // '1,2,3' rồi '[]'
function* withCleanup(): Generator<number> {
try {
yield 1
yield 2
}
finally {
console.log('cleanup: generator đã bị đóng')
}
}
for (const n of withCleanup()) {
if (n === 1) break // <- break gọi return(), finally chạy ngay
}1,2,3 [] cleanup: generator đã bị đóng
break: generator dọn dẹp đúng hợp đồng, try/finally của bạn sẽ chạy.04 — Ai nói chuyện với ai
Cấu trúc
- IterableNơi **xin** một lượt duyệt: có `[Symbol.iterator]()`. Stateless, xin bao nhiêu iterator tuỳ ý.
- IteratorChính lượt duyệt: có `next()` trả `{ value, done }`, cộng `return()` nếu cho đóng sớm. Nó **là** con trỏ.
- ConcreteIteratorPreorder (stack), BFS (queue), cursor (trang remote + con trỏ). Mỗi cái một chiến lược đi, cùng một hợp đồng.
- Collection / AggregateCây, danh sách, dataset remote. Chỉ biết cách tạo iterator, không biết ai đang duyệt mình.
- ClientChạy `for...of`, spread, `Array.from`, `yield*`. Chỉ nói chuyện với hợp đồng, không đụng field nội bộ.
Client ──for...of──► Iterable ──[Symbol.iterator]()──► Iterator
│ │ giữ state:
│ lặp next() tới khi done = true │ stack, index, con trỏ
│ break/throw → gọi return() (nếu có) │ tự nhớ đang ở đâu
└──────────── { value, done } ◄─────────────┘
Iterable = nơi XIN một lượt duyệt (stateless, xin thoải mái)
Iterator = CHÍNH lượt duyệt đó (stateful, đi tới đâu nhớ tới đó)
Generator = cả hai, viết bằng function* + yield05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: generator, iterator thủ công, và tính lười
type Tree = { value: string, children?: Tree[] }
const tree: Tree = {
value: 'app',
children: [
{ value: 'components', children: [{ value: 'Button.vue' }, { value: 'Modal.vue' }] },
{ value: 'pages', children: [{ value: 'index.vue' }] },
{ value: 'nuxt.config.ts' },
],
}
/** Generator: giá trị chỉ được sinh ra khi người gọi hỏi. */
function* walk(node: Tree): Generator<string> {
yield node.value
for (const child of node.children ?? []) yield* walk(child)
}
/** Iterator thủ công: có state (stack) và tự nhớ mình đang ở đâu. */
let touched = 0
function preorder(root: Tree) {
const stack: Tree[] = [root]
return {
next(): IteratorResult<string> {
const node = stack.pop()
if (!node) return { value: '', done: true }
touched++
for (const c of (node.children ?? []).slice().reverse()) stack.push(c)
return { value: node.value, done: false }
},
[Symbol.iterator]() { return this },
}
}
console.log('generator : ' + [...walk(tree)].join(' > '))
const it = preorder(tree)
const first3: string[] = []
for (const v of it) {
first3.push(v)
if (first3.length === 3) break
}
console.log('3 node đầu: ' + first3.join(' > ') + ' (chạm ' + touched + '/' + [...walk(tree)].length + ' node)')
console.log('duyet tiếp: ' + [...it].join(' > '))generator : app > components > Button.vue > Modal.vue > pages > index.vue > nuxt.config.ts 3 node đầu: app > components > Button.vue (chạm 3/7 node) duyet tiếp: Modal.vue > pages > index.vue > nuxt.config.ts
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
- Collection của bạn không phải mảng phẳng: cây, đồ thị, mục lục, cây thư mục, cây DOM, JSON lồng nhau — và caller chỉ muốn "cho tôi cái kế tiếp".
- Dữ liệu lớn hoặc remote: bạn muốn
for...oftrên 10.000 dòng hoặc trên một API phân trang mà không nhét tất cả vào memory trước khi bắt đầu. - Bạn cần nhiều chiến lược duyệt trên cùng một tập dữ liệu (preorder, BFS, chỉ lá, bỏ qua node bị ẩn) mà không sao chép vòng lặp.
- Bạn muốn đóng kín cấu trúc lưu trữ: đổi mảng thành Map, đổi memory sang stream, mà không sửa code UI đang duyệt nó.
- Cần nhiều vòng lặp song song trên cùng một collection, hoặc cần dừng/tiếp tục một lượt duyệt theo thời gian (scroll-load, batch job, tiến trình có thể pause).
Đừng dùng khi
- Over-engineering. Collection của bạn là
T[]và chỉ có một cách duyệt? Duyệt mảng bằngfor...ofđi, nó vốn đã là Iterator. Viết class Iterator cho mộtitems: Order[]là chữ ký của người vừa đọc xong sách pattern. - Iterator là one-shot. Lưu nó vào state/store rồi dùng lại cho lần duyệt thứ hai sẽ cho kết quả rỗng một cách im lặng. Xin iterator mới mỗi lần.
- Nhầm
for...invớifor...oflà bug kinh điển:for...inđưa về key dạng string và leo cả prototype chain, nên dùng nó trên mảng là tự rước lỗi chỉ số và key thừa;for...ofthì đòi hợp đồng iterable, do đófor...of {}throw ngay. Cầu nối đúng cho object thường làObject.entries(obj)— nó trả về mảng nên iterable, và chỉ lấy key của chính object đó. - Iterator của
Map/Setlà live: sửa map ngay trong lúc duyệt thì lượt duyệt nhìn thấy thay đổi (xoá phần tử chưa tới sẽ làm nó bị bỏ qua). Với mảng,for...ofđọclengthvà index mỗi bước nên splice giữa đường sẽ làm lệch chỉ số. Muốn an toàn: snapshot ([...map.keys()]). - Lazy không miễn phí:
for...oftrên generator remote chạy tuần tự, mỗi bước chờ một round-trip. Muốn pipeline mà vẫn mau, bạn cần async iterator (for await...of) hoặc tự batch cácnext(). Đừng dùng generator remote rồi khóc vì sao 5.000 item chạy 5.000 lần ping.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
for...of, spread, destructuring, Array.from, new Map(entries)
Tất cả đều chỉ gọi Symbol.iterator() rồi gọi next() tới khi done. Đó là lý do const [a, b] = new Set(xs), [...new Set(arr)], Array.from(document.querySelectorAll("li")), new Map(Object.entries(o)) đều chạy được với những kiểu khác nhau: chúng cùng nói một hợp đồng.
Kiểu iterable và kiểu không iterable trong JS
Iterable: Array, String, Map, Set, typed array, generator, NodeList, URLSearchParams, FormData. Không iterable: Object thường và HTMLCollection — nên document.getElementsByClassName("box") phải Array.from(...) hoặc [...] mới spread được. Lưu ý Map iterable nhưng duyệt trực tiếp cho cặp [key, value]: cần key hay value thì gọi .keys() / .values().
Cursor pagination + stream trong Node
API hiện đại trả cursor/next_token thay vì offset. Hình dạng iterator: next() fetch một trang, trả từng item, hết trang thì fetch tiếp — caller chỉ thấy for...of. Node còn nhận iterable/async iterable trực tiếp: Readable.from(asyncFunction*()) và for await (const chunk of res.body) của fetch trong Node 18+.
Vue/Nuxt: lazy list và useAsyncData theo trang
Infinite scroll/cursor load là iterator đội lốt composable: state (con trỏ, đã tải chưa) nằm trong closure của useAsyncData/composable, loadMore() chính là next(), và done là hasMore === false. Viết thành generator + for await giúp phần "lấy dữ liệu" tách khỏi phần "hiển thị" — cùng một lợi ích đóng kín cấu trúc.
08 — Tự tay làm
Bài tập
Làm cho `Tree` của bạn ** iterable** mà không đổi cách nó lưu `children`: thêm `[Symbol.iterator]()` (preorder) và một generator `*leaves()` chỉ trả node lá. Kiểm tra: `[...app]`, `[...app.leaves()]`, và `for (const v of app) { if (...) break }` chạy được, và hai vòng lặp lồng nhau không giẫm nhau.
Gợi ý, mở từng cái một:
- State của lượt duyệt đặt ở đâu? Gợi ý: trong closure của chính
[Symbol.iterator](), không đặt trên instance — nếu đặt trên instance thì hai vòng lặp lồng nhau sẽ ghi đè con trỏ của nhau. - Cần
slice().reverse()trước khi push children vào stack, nếu không thứ tự anh-em sẽ lộn. (Hoặc đổi sangqueue.shift()nếu bạn muốn BFS.) *leaves()không cần stack: chỉyieldkhichildren.length === 0, còn lạiyield*cho cây con.
[Symbol.iterator]() tạo mỗi lần gọi một stack riêng trong closure và trả về iterator tự nhớ vị trí — đó là lý do hai vòng lặp lồng nhau độc lập. *leaves() là generator đệ quy dùng yield*. Không ai trong hai cái chạm tới cấu trúc lưu trữ, nên bạn đổi children thành Map mà caller không biết.
class Tree {
constructor(public value: string, public children: Tree[] = []) {}
[Symbol.iterator](): Iterator<string> {
const stack: Tree[] = [this] // state RIÊNG cho từng lượt duyệt
return {
next(): IteratorResult<string> {
const n = stack.pop()
if (!n) return { value: undefined as unknown as string, done: true }
stack.push(...n.children.slice().reverse())
return { value: n.value, done: false }
},
}
}
*leaves(): Generator<string> {
if (this.children.length === 0) yield this.value
else for (const c of this.children) yield* c.leaves()
}
}
const app = new Tree('app', [
new Tree('pages', [new Tree('index.vue')]),
new Tree('nuxt.config.ts'),
])
console.log([...app].join(' > ')) // app > pages > index.vue > nuxt.config.ts
console.log([...app.leaves()].join(', ')) // index.vue, nuxt.config.ts09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- CompositeCây là Composite, và iterator preorder/BFS chỉ đi được nhờ mọi node cùng một kiểu. Two pattern này gần như luôn xuất hiện cùng nhau.
- StrategyPreorder, BFS, chỉ-lá, bỏ-qua-node-ẩn là **các chiến lược duyệt** được đặt sau cùng một hợp đồng `next()`. Iterator là Strategy cho việc đi.
- Chain of ResponsibilityCùng tách người gọi khỏi người xử lý, nhưng theo trục khác: CoR trả lời "ai xử lý cái này", Iterator trả lời "cái kế tiếp là cái nào".
- MementoMuốn **tạm dừng rồi tiếp tục** một lượt duyệt (hoặc tua lại) thì state của iterator chính là thứ cần lưu — Memento là cách đặt tên cho nó.