Pattern 12/22 · Behavioral

State Trạng thái

Gói mỗi trạng thái của một đối tượng thành một tập hành vi riêng, để chính trạng thái quyết định hành động nào hợp lệ và nó tự chuyển sang trạng thái nào — thay vì bắt mọi nơi khác đoán `status` bằng if/else.

Hành vi●●○14 phút đọc8 bướccòn gọi: State Machine, FSM, States
state machineif elsetrạng tháitransitionbehavioraltypescript

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

Vấn đề

Shop của bạn có class Order với field status. Nghiệp vụ khởi đầu đơn giản: khách đặt thì pending, thanh toán xong thì paid, kho gửi hàng thì shipped. Bạn viết pay(), ship(), cancel() — mỗi hàm mở đầu bằng vài dòng kiểm tra status, rồi làm việc của nó. Mọi thứ chạy tốt.

Sang quý sau có thêm refunded, failed, partially_refunded, và hai luật mới: đơn COD được gửi trước khi paid, đơn đã hoàn tiền thì không được ship. Mỗi luật mới nghĩa là bạn phải mở tất cả các hàm của Order, vì mỗi hàm đang tự nhớ một mảnh luật của riêng nó. ship() thiếu đúng một dòng check refund là hàng đã ra khỏi kho cho một đơn khách nhận tiền lại rồi.

Rồi status rò rỉ ra khỏi class. Trang chi tiết đơn có if (order.status === "paid") để hiện nút "Gửi hàng". API guard có một check cùng nội dung. Con cron báo cáo có cây switch thứ ba. Cùng một sự thật — "từ paid được phép sang shipped" — được viết lại ở ba nơi, và một trong ba nơi đó nằm trong repo của team khác.

Kiểu bug đặc trưng của code dạng này không phải "sai công thức" mà là transition không hợp lệ lọt qua. Hai webhook cancel đến cùng lúc, cả hai đều thấy status === "paid" đều thoả điều kiện, và đơn bị hoàn tiền hai lần. Không có chỗ nào định nghĩa "đang ở trạng thái này thì chỉ được đi tới những trạng thái kia", nên mỗi caller tự chịu trách nhiệm nhớ — và ai cũng nhớ thiếu.

Nói gọn: hành vi của object phụ thuộc vào dữ liệu status, nhưng luật "status nào được làm gì, đi đâu được" lại không nằm ở đâu tập trung. State Machine là cách biến cái luật vô hình, phân tán đó thành một thứ hữu hình: đọc được hết trong một màn hình, chặn được transition sai, và test được bằng một vòng lặp.

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

Giải pháp

Mỗi trạng thái là một đơn vị code riêng, chứa hành vi áp dụng khi ở trạng thái đó cùng danh sách trạng thái kế tiếp hợp lệ. Order chỉ còn là cái vỏ: giữ trạng thái hiện tại, nhận lệnh, giao cho trạng thái hiện tại xử lý, rồi đổi trạng thái nếu trạng thái đó cho phép. Không module nào khác trong hệ thống còn được quyền hỏi "status là gì" để tự quyết định.

Trong TypeScript, thứ bạn cần đa số không phải "một class cho mỗi state" mà là một bảng chuyển trạng thái: Record<Từ, Đến[]>, thêm guard nếu cần. Bảng đó là cái machine — đọc hết 10 giây, serialize ra JSON để cho UI render nút, và mọi lần đổi trạng thái đi qua đúng một hàm. Transition sai chết ngay ở ranh giới đó, không tới được business logic. Bản GoF (mỗi state một class) chỉ đáng dùng khi mỗi state có nhiều hành vi riêng, không chỉ có "được phép đi đâu".

Đừng nhầm với Strategy: cấu trúc code của hai pattern này gần như giống hệt — một object delegate cho một object khác. Intent ngược nhau. Strategy là client chọn thuật toán ("hôm nay tính phí kiểu này"), State là chính trạng thái quyết định và nó tự chuyển mình ("đang paid thì ship() hợp lệ, submit() thì không"). Nếu bạn viết State mà client vẫn gọi order.setState(x) từ ngoài, bạn đã viết Strategy dưới cái tên khác.

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

Từng bước một

1

Vẽ machine trước: tập state và tập transition

Trước khi code, liệt kê hai thứ: tập state hữu hạn và tập transition hợp lệ (from → to, kèm điều kiện). Nếu bạn không liệt kê được hai danh sách này, bạn chưa hiểu nghiệp vụ — đừng vội viết class.

Viết bảng đó ra file, đặt cạnh code và review nó với người làm nghiệp vụ, không chỉ với compiler. Đây chính là deliverable thật của pattern; code chỉ là bản dịch của bảng.

textorder-machine.txt
STATE      ACTION     NEXT        AI GOI
draft      submit     pending     khach bam "Dat hang"
draft      cancel     cancelled   khach huy truoc khi thanh toan
pending    pay        paid        webhook tu cong thanh toan
pending    expire     cancelled   cron: hop thanh toan het gio
paid       ship       shipped     nhan vien kho
paid       refund     cancelled   CS khach hang
shipped    (khong co transition nao)   <- state ket thuc
cancelled  (khong co transition nao)   <- state ket thuc
Tám dòng này là toàn bộ nghiệp vụ đơn hàng. Bug "double refund" không nằm trong bảng, nên nó không thể chạy.
ChốtMachine = tập state + tập transition. Viết hai cái đó ra không được thì chưa có gì để refactor.
2

Viết phiên bản mùi code, để thấy nó hỏng chỗ nào

Code này ai cũng từng viết, và nó không sai ngày hôm nay. Nó sai ở release thứ ba, khi số luật đã vượt quá sức nhớ của một người đọc từng hàm.

tsorder-v1.ts
type Status = 'draft' | 'pending' | 'paid' | 'shipped' | 'cancelled'

class Order {
  status: Status = 'draft'
  refunded = false

  pay(): void {
    if (this.status !== 'pending') throw new Error('khong the thanh toan')
    this.status = 'paid'
  }

  ship(): void {
    if (this.status !== 'paid') throw new Error('khong the gui')
    this.status = 'shipped'   // BUG: không biết refund có thể đang diễn ra
  }

  cancel(): void {
    if (this.status === 'shipped') throw new Error('hang di roi')
    this.refunded = true
    this.status = 'cancelled'
  }
}
Mỗi hàm tự nhớ luật của mình. Tổ hợp paid → refund đang chạy → ship không hàm nào nghĩ tới lúc viết.
ChốtCái mùi không phải là if. Mùi là luật transition bị phân tán, mỗi hàm giữ một mảnh và không mảnh nào thấy bức tranh.
3

Định nghĩa hợp đồng của một state

Mỗi state là một object cùng hình dạng. Nó nhận đối tượng ngữ cảnh và tự trả lời: hành động này có hợp lệ không, state kế tiếp là gì.

Dấu ? mang thông điệp: state không có method đó thì hành động đó không tồn tại ở trạng thái này. Bạn không cần viết if (status === ...) throw nữa.

tsorder-state.ts
import type { Order } from './order'

export type Status = 'draft' | 'pending' | 'paid' | 'shipped' | 'cancelled'
export type Action = 'submit' | 'pay' | 'ship' | 'refund' | 'cancel' | 'expire'

/** Hợp đồng: một state khai báo action nào nó nhận, và action đó dẫn tới đâu. */
export interface OrderState {
  readonly name: Status
  submit?(o: Order): OrderState
  pay?(o: Order): OrderState
  ship?(o: Order): OrderState
  refund?(o: Order): OrderState
  cancel?(o: Order): OrderState
  expire?(o: Order): OrderState
}
Interface này đứng yên khi mọi luật nghiệp vụ thay đổi. Nó mô tả "hình dạng của câu hỏi", không mô tả câu trả lời.
ChốtCâu hỏi đúng không còn là "status có phải paid không" mà là "state hiện tại có method ship() không".
4

Mỗi state tự chứa hành vi và transition của nó

Toàn bộ machine đọc được trong một màn hình, và mỗi dòng thuộc về đúng một state. Nghiệp vụ mới ("COD được ship trước khi pay") là một method thêm vào pending, không phải một bản vá rải trên bốn file.

tsstates.ts
import type { OrderState } from './order-state'

export const draft: OrderState = {
  name: 'draft',
  submit: () => pending,
  cancel: () => cancelled,
}

export const pending: OrderState = {
  name: 'pending',
  pay: () => paid,
  expire: () => cancelled,
}

export const paid: OrderState = {
  name: 'paid',
  ship: () => shipped,
  refund: () => cancelled,
}

export const shipped: OrderState = { name: 'shipped' }     // state kết thúc
export const cancelled: OrderState = { name: 'cancelled' } // state kết thúc
State không gọi state khác — nó chỉ trả về state kế tiếp. Ai đổi con trỏ state là chuyện của Context (bước sau).
ChốtThêm state = thêm object. Thêm transition = thêm một dòng trong đúng một object. Open/Closed theo nghĩa đen.
5

Context chỉ delegate, không tự đoán

Order giờ không biết gì về nghiệp vụ chuyển trạng thái. Nó biết đúng một việc: hỏi state hiện tại, và nếu state từ chối thì báo lỗi có ngữ cảnh ("đang paid nên không submit được") thay vì crash ở một nơi vô nghĩa.

Để machine còn nghĩa, mọi hành động phải đi qua apply(). Nếu chỗ nào đó gán order.state = ... trực tiếp, machine đó chỉ là trang trí.

tsorder.ts
import type { Action, OrderState } from './order-state'
import { draft } from './states'

export class Order {
  private state: OrderState = draft

  constructor(readonly id: string) {}

  private apply(action: Action): void {
    const run = this.state[action] as ((o: Order) => OrderState) | undefined
    const next = run?.(this)
    if (!next) {
      throw new Error(this.id + ': khong the ' + action + ' khi dang "' + this.state.name + '"')
    }
    console.log(this.id + ': ' + this.state.name + ' -> ' + next.name)
    this.state = next
  }

  submit() { this.apply('submit') }
  pay() { this.apply('pay') }
  ship() { this.apply('ship') }
  refund() { this.apply('refund') }
}
Không còn branch nào chứa nghiệp vụ trong Context. Muốn thêm hành động mới: thêm một method delegate một dòng.
ChốtNếu vẫn còn module nào phải đọc status để quyết định, machine của bạn chưa xong.
6

Bản thực dụng: transition table, không cần class-per-state

Sự thật ít ai nói: phần lớn state trong app không có hành vi riêng, chúng chỉ chặn một số action. Với loại đó, một class riêng là thủ công vô ích. Bảng chuyển trạng thái diễn đạt cùng machine bằng dữ liệu: log được, trả về cho client, test bằng một vòng lặp, và cho PM đọc không cần biết TypeScript.

Hai bản không xung đột. Khởi đầu bằng bảng; khi một state bắt đầu chứa logic phức tạp (tính lại tồn kho, gọi API hoàn tiền), nâng đúng state đó lên object. Machine vẫn là một.

tstable-machine.ts
type S = 'draft' | 'pending' | 'paid' | 'shipped' | 'cancelled'

/** from -> danh sach to hop le. Ngoài danh sách này là BUG, không phải "case chưa viết". */
export const NEXT: Record<S, S[]> = {
  draft: ['pending', 'cancelled'],
  pending: ['paid', 'cancelled'],
  paid: ['shipped', 'cancelled'],
  shipped: [],
  cancelled: [],
}

export function go(from: S, to: S): S {
  if (!NEXT[from].includes(to)) throw new Error(from + ' -> ' + to + ' khong hop le')
  return to
}

// Test toàn bộ machine = 6 dòng:
// for (const [from, tos] of Object.entries(NEXT))
//   for (const to of tos) expect(() => go(from as S, to)).not.toThrow()
ChốtState (GoF) và transition table là cùng một machine, khác chỗ đặt hành vi: một bên trong class, một bên trong data. Chọn data cho tới khi hành vi dày lên.
7

Chặn transition sai tại đúng một ranh giới

Giá trị lớn nhất của machine không phải code gọn hơn, mà là transition sai không chạm được tới business logic. Điều kiện tiên quyết: mọi đường đổi trạng thái đi qua một hàm duy nhất — API route, cron, migration script, test. Đường vòng qua hàm đó là lỗ hổng, không phải tối ưu.

Máy trạng thái còn cho bạn idempotency gần như miễn phí. Webhook thanh toán bắn tới hai lần: lần hai là paid → paid, không có trong bảng, bị chặn ở cửa. Không cần khoá phân tán cho case này, và log của bạn nói toang lên thay vì im lặng tính tiền hai lần.

tsmachine.ts
export class Machine<S extends string> {
  constructor(private state: S, private next: Record<S, S[]>) {}

  get current(): S {
    return this.state
  }

  /** Lỗi ném ra ở đây là TÍN HIỆU TỐT: nó chặn bug ở ranh giới thay vì cho nó chạy tiếp. */
  to(to: S): void {
    if (!this.next[this.state].includes(to)) {
      throw new Error(this.state + ' -> ' + to + ' bi chan')
    }
    this.state = to
  }

  /** Cho UI/API hỏi "tu day di duoc nao?" — may tron, khong ném loi. */
  can(to: S): boolean {
    return this.next[this.state].includes(to)
  }
}
ChốtNếu transition sai chỉ bị chặn ở UI thì bạn chưa có machine — bạn mới có một gợi ý.
8

Cho UI và API đọc machine, đừng bắt họ tự nhớ

Machine chỉ thật sự xong khi không còn ai tự đoán trạng thái. Trang chi tiết đơn hàng không viết if (status === "paid"); nó hỏi machine "từ trạng thái này action nào hợp lệ" rồi render nút theo danh sách đó. Nghiệp vụ đổi, nút đổi theo, không ai phải sửa template.

Cùng một danh sách đó dùng cho API guard: request ship trên đơn draft bị chặn trước khi vào handler, với thông báo lỗi giải thích được thay vì 500 vô danh.

tsallowed-actions.ts
import type { Action, Status } from './order-state'

const ACTIONS: Record<Status, Action[]> = {
  draft: ['submit', 'cancel'],
  pending: ['pay', 'cancel'],
  paid: ['ship', 'refund'],
  shipped: [],
  cancelled: [],
}

/** Nguồn chân lý duy nhất cho cả nút bấm lẫn API guard. */
export const allowedActions = (state: Status): Action[] => ACTIONS[state]

// component: allowedActions('paid') -> ['ship', 'refund'] -> render 2 nút
// api:         if (!allowedActions(order.status).includes(action)) return 409
Nút bấm không còn là kiến thức nghiệp vụ nằm trong template — đó là nơi refactor này bắt đầu có lãi.
ChốtBao giờ còn thấy status === "paid" trong template là lúc đó còn một machine chưa được dùng.

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

Cấu trúc

  • StateHợp đồng: action nào một trạng thái trả lời được, và action đó dẫn tới state nào.
  • ConcreteState`draft`, `pending`, `paid`... Chỉ chứa hành vi của chính nó; biết state khác đúng bằng tên kế tiếp nó trả về.
  • Context (Order)Giữ state hiện tại, delegate action xuống state, đổi state nếu state cho phép. Không chứa luật transition.
  • TransitionTableMachine viết bằng dữ liệu: `from → next[]`. Thay cho class-per-state khi hành vi mỏng, và là nguồn cho UI/API guard.
  • Client / UIGửi action, hỏi `allowedActions(state)`. Không đọc `status` để tự quyết định.
  UI / API / cron
        │ action (submit | pay | ship | refund)
        ▼
┌──────────────────────────────────────────────┐
│ Context: Order                               │
│   state: OrderState                          │
│   apply(a) → state[a]?.(this) → state = next │  ← chặn ở đây,
└───────────────────┬──────────────────────────┘    business logic
                    │ delegate, không tự xét status    không thấy gì
      ┌─────────────┼──────────────┬──────────────┐
      ▼             ▼              ▼              ▼
 ┌─────────┐  ┌──────────┐  ┌──────────┐  ┌────────────┐
 │  draft  │  │ pending  │  │   paid   │  │  shipped / │
 │ submit  │  │ pay      │  │ ship     │  │ cancelled  │
 │ cancel  │  │ expire   │  │ refund   │  │ (khong co  │
 └────┬────┘  └────┬─────┘  └────┬─────┘  │  action)   │
      │ pending    │ paid        │ shipped └────────────┘
      └───────────►└────────────►└──────────────► KET THUC

  Action khong co trong state hien tai  →  loi ngay tai apply().

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

Chạy thử: máy trạng thái đơn hàng chặn transition sai

tsdemo.ts
type S = 'draft' | 'pending' | 'paid' | 'shipped' | 'cancelled'

// Bảng transition hợp lệ. Ngoài bảng này là BUG, không phải "case chưa viết".
const NEXT: Record<S, S[]> = {
  draft: ['pending', 'cancelled'],
  pending: ['paid', 'cancelled'],
  paid: ['shipped', 'cancelled'],
  shipped: [],
  cancelled: [],
}

const LABEL: Record<S, string> = {
  draft: 'bản nháp',
  pending: 'chờ thanh toán',
  paid: 'đã thanh toán',
  shipped: 'đã gửi',
  cancelled: 'đã huỷ',
}

class Order {
  private state: S = 'draft'
  constructor(readonly id: string) {}

  get status(): string {
    return LABEL[this.state]
  }

  to(next: S): void {
    if (!NEXT[this.state].includes(next)) {
      console.log('  ✗ ' + this.id + ': ' + this.state + ' -> ' + next + ' (bị chặn)')
      return
    }
    console.log('  ✓ ' + this.id + ': ' + this.state + ' -> ' + next)
    this.state = next
  }
}

const don = new Order('DH-01')
don.to('paid')      // nhảy giai đoạn
don.to('pending')
don.to('paid')
don.to('shipped')
don.to('cancelled') // hàng đã đi rồi
console.log('  kết quả: ' + don.status)
console
  ✗ DH-01: draft -> paid (bị chặn)
  ✓ DH-01: draft -> pending
  ✓ DH-01: pending -> paid
  ✓ DH-01: paid -> shipped
  ✗ DH-01: shipped -> cancelled (bị chặn)
  kết quả: đã gửi

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

  • Hành vi của object đổi theo dữ liệu trạng thái, và số transition đã ≥ 5 hoặc còn tăng. Ba state với một đường thẳng thì enum là đủ.
  • Có transition không hợp lệ và cái giá của nó là thật: hoàn tiền hai lần, gửi hàng cho đơn đã huỷ, đăng bài hai lần.
  • Cùng một luật "được làm gì lúc này" phải dùng ở nhiều nơi: UI, API guard, cron, worker. Một nguồn chân lý, nhiều chỗ hỏi.
  • Bạn cần audit trail: ai chuyển từ state nào sang state nào, lúc nào. Machine gom hết về một hàm nên log một lần là đủ.
  • Luật transition là nghiệp vụ cần review với non-engineer: bảng state/transition đọc được, code trong if/else thì không.
  • Cần idempotency cho lệnh lặp lại (webhook, retry, user bấm đúp): transition trùng nằm ngoài bảng nên tự nhiên bị chặn.

Đừng dùng khi

  • Over-engineering. Hai state, một chiều, không có transition cấm? Enum plus if là đúng. Machine là khoản đầu tư chỉ có lãi khi luật đã phức tạp hoặc còn phình.
  • Machine chỉ có nghĩa nếu mọi đường đổi trạng thái đi qua nó. Một chỗ order.status = "paid" ghi thẳng ra DB ở file migration là machine đó thành truyện cười.
  • State nhét logic vào UI sẽ buộc UI phải biết nghiệp vụ. Hãy lộ allowedActions(state) ra ngoài, đừng lộ state === "paid".
  • State machine không tự giải quyết tính đồng thời. Hai request đồng thời đọc cùng state rồi cùng chuyển: cần ràng buộc ở tầng lưu (optimistic lock, UPDATE ... WHERE status = ...), machine chỉ chặn phần hợp lệ/không hợp lệ.
  • Dùng class cho 5 state không có hành vi riêng là tự tạo 5 file vô ích. Bảng dữ liệu nhỏ hơn, test nhanh hơn, và nói cùng một điều.

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

Trong code thật

WebSocket.readyState

API thật của browser là một state machine: CONNECTING → OPEN → CLOSING → CLOSED. Gọi send() khi readyState là CONNECTING sẽ ném InvalidStateError. Đây là thiết kế có chủ đích: hành động không hợp lệ bị chặn tại ranh giới, đúng tinh thần của pattern.

useAsyncData / useFetch trong Nuxt

Composable này phơi status: "idle" | "pending" | "success" | "error", và component cư xử khác nhau theo từng giá trị (pending thì skeleton, error thì retry). Phần render theo trạng thái chính là phần "hành vi phụ thuộc state"; phần transition nằm trong composable.

Reducer trong Redux/Zustand

(state, action) => next đúng là hàm chuyển trạng thái của một machine. Điểm mạnh của mô hình reducer nằm ở đây: action không hợp lệ thường trả về nguyên state cũ, nên state không thể rơi vào tổ hợp "không có transition".

XState / @xstate/vue

Khi machine phình thật (guard, side effect, machine lồng nhau, machine song song), cấu hình khai báo + visualizer của XState đáng dùng hơn bảng Record tự viết. Nó cũng là State + TransitionTable đóng gói sẵn cho Vue/React.

Node.js stream

res.end() hai lần ném ERR_STREAM_ALREADY_FINISHED; write sau destroy() ném lỗi. Core Node giữ một máy trạng thái nhỏ cho mỗi stream và từ chối operation sai thời điểm, thay để buffer âm thầm mất dữ liệu.

08 — Tự tay làm

Bài tập

Chuyển quy trình bài viết sau sang một máy trạng thái có chặn transition sai: `draft → review → approved → published`, kèm `review → draft` (bị reject) và `draft | review → archived`. Viết demo chạy `publish` trên bài đang `draft` (phải bị chặn) rồi chạy đúng trình tự.

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

  1. Viết bảng Record<Status, Status[]> trước. published: [] và archived: [] là state kết thúc — đừng quên chúng, thiếu là TypeScript báo thiếu key.
  2. Một hàm duy nhất to(next) thực hiện mọi chuyển; đừng để code gọi gán status trực tiếp.
  3. Thêm can(next): boolean để API/page hỏi trước, dành cho chỗ không muốn nhận exception.

Bảng transition là nguồn chân lý; hàm to() chặn mọi thứ ngoài bảng và ném lỗi nêu rõ "từ đâu đến đâu". can() là phiên bản không ném lỗi cho UI. Demo in ra 4 dòng: một lần bị chặn, ba lần thành công.

tsbai-tap.ts
type S = 'draft' | 'review' | 'approved' | 'published' | 'archived'

const NEXT: Record<S, S[]> = {
  draft: ['review', 'archived'],
  review: ['approved', 'draft', 'archived'],
  approved: ['published'],
  published: [],
  archived: [],
}

class Post {
  private state: S = 'draft'
  constructor(readonly slug: string) {}

  can(to: S): boolean {
    return NEXT[this.state].includes(to)
  }

  to(to: S): void {
    if (!this.can(to)) {
      console.log('  x ' + this.slug + ': ' + this.state + ' -> ' + to + ' bi chan')
      return
    }
    console.log('  o ' + this.slug + ': ' + this.state + ' -> ' + to)
    this.state = to
  }
}

const p = new Post('state-pattern')
p.to('published')   // chưa review -> phải bị chặn
p.to('review')
p.to('approved')
p.to('published')

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

Pattern liên quan

  • StrategyCode gần như giống hệt, intent ngược: Strategy để **client chọn** thuật toán, State để **trạng thái tự quyết định** và tự chuyển mình. Đọc cặp này để hiểu ý nghĩa quan trọng hơn cấu trúc.
  • CommandGói mỗi transition thành object (`Pay`, `Ship`) thì bạn log, xếp hàng, retry và undo được. Command là cách "hành động" bước ra khỏi máy trạng thái còn State lo "được phép hay không".
  • ObserverMỗi lần machine đổi state, thông báo để UI cập nhật, audit log ghi lại, side effect chạy. Cặp State + Observer thay cho việc mỗi module tự polling `status`.
  • MementoMachine lưu lịch sử state thì `undo` = quay về memento trước. Đặc biệt hợp với wizard nhiều bước và form có nút "Quay lại".