Pattern 02/22 · Behavioral
Strategy Chiến lược
Tách một thuật toán hay thay đổi thành các object rời nhau (các "chiến lược"), rồi để đối tượng dùng nó chọn chạy lúc runtime thay vì hard-code bằng if/else.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Bạn viết tính phí vận chuyển cho một shop online. Đơn thường: 30.000đ. Hỏa tốc: 30.000 + 10.000/kg. Đơn từ 500k: miễn phí. Khách VIP: giảm 50%. Bạn viết cái đầu tiên trong 2 phút:
Rồi sản phẩm thêm loại thứ hai, thứ ba, thứ tư. Hàm calculateShipping() phình thành một cây if/else dài dằng dặc. Mỗi lần marketing đổi một con số, bạn lại sửa đúng hàm đó — và mỗi lần sửa lại có nguy cơ làm hỏng một nhánh mà bạn không nghĩ tới.
Tệ hơn: hàm này không test riêng được. Muốn test "hỏa tốc cho đơn 3kg", bạn phải dựng cả một object Order rồi gọi một hàm to đùng chứa cả logic của mấy loại khác. Và khi hai team cùng sửa hai nhánh khác nhau của cùng một if/else, conflict là chuyện hằng ngày.
Vấn đề thật sự không phải là if/else — mà là nhiều cách làm khác nhau của cùng một việc bị nhét chung vào một chỗ, và code gọi nó phải biết hết mọi khả năng.
02 — Ý tưởng, chưa động vào code
Giải pháp
Chiến lược là: mỗi cách tính phí trở thành một object riêng, tất cả cùng chung một cái "hợp đồng" (interface). Chỗ cần tính phí chỉ gọi hợp đồng đó, không cần biết bên trong là gì.
Phần không đổi (quy trình checkout: lấy địa chỉ → tính phí → tạo đơn) nằm lại trong class ngữ cảnh. Phần hay đổi (công thức tính phí) nằm ở các class chiến lược, mỗi class một file, mỗi file một trách nhiệm. Muốn thêm loại phí mới? Thêm file mới. Không sửa code cũ.
Trong TypeScript/JavaScript, một "object cùng giao diện" thường chỉ là một function. Vậy nên phiên bản phổ biến nhất của Strategy trong JS không cần interface nào cả — nó là function được truyền vào làm tham số. Bạn đã dùng Strategy cả trăm lần: array.sort((a, b) => a.price - b.price).
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Viết phiên bản "bad smell" trước đã
Đây là code mà ai cũng viết lần đầu. Đừng sợ nó — hãy nhận diện đúng chỗ nào sẽ phình.
type ShippingType = 'standard' | 'express' | 'free' | 'vip'
class Checkout {
calculateShipping(order: { total: number, weightKg: number }, type: ShippingType): number {
if (type === 'standard') {
return 30_000
}
else if (type === 'express') {
return 30_000 + order.weightKg * 10_000
}
else if (type === 'free') {
return order.total >= 500_000 ? 0 : 20_000
}
else if (type === 'vip') {
return order.total * 0.5 * 0.5 // giảm 50%, vẫn tính phí thường
}
throw new Error('loai van chuyen khong ton tai: ' + type)
}
}else if thứ 5 sẽ đến rất nhanh.if/else, và mỗi nhánh chỉ khác nhau ở cách tính, không khác nhau ở kết quả trả về.Tách phần hay đổi khỏi phần không đổi
Trước khi viết code, cầm bút gạch chân. Trong quy trình checkout, phần không đổi: nhận đơn, kiểm tra địa chỉ, gọi tính phí, lưu đơn, gửi email. Phần hay đổi: mỗi nơi chỉ có một dòng — dòng gọi tính phí.
Vậy ta chỉ cần rút đúng một thứ ra: "tính phí từ đơn hàng". Hợp đồng của nó: đầu vào Order, đầu ra number. Viết hợp đồng đó thành type.
export type Order = { id: string, total: number, weightKg: number }
/** Cái "hợp đồng": mọi cách tính phí đều phải khớp hình dạng này. */
export interface ShippingStrategy {
readonly name: string
fee(order: Order): number
}Biến mỗi thuật toán thành một chiến lược
Mỗi nhánh if/else cũ trở thành một object. Mỗi object một file (hoặc một cụm nhỏ cùng file nếu nó đơn giản). Không object nào biết đến các object khác.
import type { Order, ShippingStrategy } from './shipping-strategy'
export const standardShipping: ShippingStrategy = {
name: 'standard',
fee: () => 30_000,
}
export const expressShipping: ShippingStrategy = {
name: 'express',
fee: (o: Order) => 30_000 + Math.round(o.weightKg) * 10_000,
}
export const freeOver500k: ShippingStrategy = {
name: 'free-over-500k',
fee: (o: Order) => (o.total >= 500_000 ? 0 : 20_000),
}
export const vipDiscount: ShippingStrategy = {
name: 'vip',
fee: (o: Order) => Math.round(standardShipping.fee(o) * 0.5),
}Checkout.Cho ngữ cảnh nhận chiến lược từ bên ngoài
Checkout giờ chỉ còn là ngữ cảnh (context): nó chạy quy trình và uỷ quyền phần tính phí cho một chiến lược được truyền vào. Nó không new chiến lược nào, không so sánh type === ... nào.
import type { Order, ShippingStrategy } from './shipping-strategy'
export class Checkout {
constructor(private strategy: ShippingStrategy) {}
total(order: Order): number {
return order.total + this.strategy.fee(order)
}
report(order: Order): void {
const fee = this.strategy.fee(order)
console.log(`${order.id} · ${this.strategy.name}: phí ${fee}đ, tổng ${order.total + fee}đ`)
}
}if. Không còn throw new Error("loai khong ton tai") — TypeScript chặn nó ngay tại chỗ gọi.Chọn chiến lược lúc chạy (thay vì lúc viết code)
Khách đổi từ "thường" sang "hỏa tốc" ngay trên trang thanh toán? Đổi chiến lược. Đây là toàn bộ sức mạnh của pattern: cùng một đối tượng, hành vi khác nhau theo thời gian.
import { Checkout } from './checkout-v2'
import { standardShipping, expressShipping, freeOver500k } from './strategies'
const don: Order = { id: 'DH-01', total: 640_000, weightKg: 3 }
const checkout = new Checkout(standardShipping)
checkout.report(don)
checkout.setStrategy(expressShipping) // khách bấm "Hỏa tốc"
checkout.report(don)
checkout.setStrategy(freeOver500k) // có mã giảm giá
checkout.report(don)DH-01 · standard: phí 30000đ, tổng 670000đ DH-01 · express: phí 60000đ, tổng 700000đ DH-01 · free-over-500k: phí 0đ, tổng 640000đ
Thay if/else bằng registry khi chiến lược đến từ dữ liệu
Trong đời thực, chiến lược thường đến từ DB, từ query string, từ config admin: ?shipping=express. Lúc này bạn không import từng cái rồi if, bạn tra trong một map. if/else biến mất hoàn toàn.
import type { ShippingStrategy } from './shipping-strategy'
import { standardShipping, expressShipping, freeOver500k, vipDiscount } from './strategies'
export const shippingRegistry: Record<string, ShippingStrategy> = {
'standard': standardShipping,
'express': expressShipping,
'free-over-500k': freeOver500k,
'vip': vipDiscount,
}
export function pickShipping(key: string): ShippingStrategy {
const found = shippingRegistry[key]
if (!found) throw new Error(`Không có chiến lược vận chuyển "${key}"`)
return found
}
// router/server: const strategy = pickShipping(query.shipping ?? 'standard')Bản JS thuần: chiến lược chỉ là một function
Nếu chiến lược không giữ state, object { name, fee() } là thủ công thừa. Trong TS, function là first-class, nên hợp đồng co lại còn một type:
export type FeeFn = (order: Order) => number
export const calculateTotal = (order: Order, fee: FeeFn = o => (o.total >= 500_000 ? 0 : 30_000)) =>
order.total + fee(order)
calculateTotal({ id: 'DH-02', total: 120_000, weightKg: 1 }) // 150000
calculateTotal({ id: 'DH-02', total: 120_000, weightKg: 1 }, () => 0) // 120000
// và đây chính là Strategy bạn đã viết cả năm nay:
[12, 4, 9].sort((a, b) => a - b) // [4, 9, 12]
[12, 4, 9].sort((a, b) => b - a) // [12, 9, 4] <- cùng sort(), khác chiến lượcKiểm tra lại: đã đóng được chưa, mở được chưa
Bài test cuối cùng của refactor này: thêm một loại phí mới mà không sửa bất kỳ file cũ nào. Nếu bạn phải sửa Checkout hay một chiến lược cũ, nghĩa là còn chỗ nào đó "biết" quá nhiều.
// File MỚI. Duy nhất. Không sửa gì khác.
import type { ShippingStrategy } from './shipping-strategy'
export const nightShift: ShippingStrategy = {
name: 'night-shift',
fee: (o) => (o.weightKg <= 2 ? 15_000 : 40_000),
}
// + 1 dòng trong registry: 'night-shift': nightShift04 — Ai nói chuyện với ai
Cấu trúc
- StrategyHợp đồng chung cho mọi thuật toán: `fee(order): number`.
- ConcreteStrategyMột cách tính cụ thể: standard, express, vip... Không biết gì về nhau.
- ContextChạy quy trình chung, giữ một tham chiếu Strategy, gọi `strategy.fee()` đúng lúc.
- ClientChọn và (nếu cần) đổi chiến lược cho Context, thường dựa trên input/user/config.
┌────────────────┐
Client │ chọn/đổi │
─────────►│ chiến lược │
└───────┬────────┘
│ setStrategy(s)
▼
┌──────────────────────────────┐
│ Context (Checkout) │ chỉ chạy quy trình chung
│ - strategy: ShippingStrategy│
│ + total(order) ──► strategy.fee(order)
└──────────────┬───────────────┘
│ dùng hợp đồng, không biết implementation
┌─────────┼──────────────┐
▼ ▼ ▼
┌─────────┐┌─────────┐ ┌──────────┐
│standard ││ express │ │ vip │ ... thêm file mới
│30.000đ ││+10k/kg │ │ 50% phí │ tuỳ ý
└─────────┘└─────────┘ └──────────┘05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: một Checkout, ba chiến lược
type Order = { id: string, total: number, weightKg: number }
interface ShippingStrategy {
readonly name: string
fee(order: Order): number
}
const standard: ShippingStrategy = {
name: 'standard',
fee: () => 30_000,
}
const express: ShippingStrategy = {
name: 'express',
fee: o => 30_000 + Math.round(o.weightKg) * 10_000,
}
const freeOver500k: ShippingStrategy = {
name: 'free-over-500k',
fee: o => (o.total >= 500_000 ? 0 : 20_000),
}
// Registry: thêm loại phí mới = thêm 1 dòng, không sửa Checkout
const registry: Record<string, ShippingStrategy> = {
'standard': standard,
'express': express,
'free-over-500k': freeOver500k,
}
class Checkout {
constructor(private strategy: ShippingStrategy) {}
setStrategy(s: ShippingStrategy) {
this.strategy = s
}
report(order: Order) {
const fee = this.strategy.fee(order)
console.log(`${order.id} · ${this.strategy.name}: phí ${fee}đ, tổng ${order.total + fee}đ`)
}
}
const don: Order = { id: 'DH-01', total: 640_000, weightKg: 3 }
const checkout = new Checkout(registry['standard'])
checkout.report(don)
checkout.setStrategy(registry['express'])
checkout.report(don)
checkout.setStrategy(registry['free-over-500k'])
checkout.report(don)DH-01 · standard: phí 30000đ, tổng 670000đ DH-01 · express: phí 60000đ, tổng 700000đ DH-01 · free-over-500k: phí 0đ, tổng 640000đ
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
- Nhiều class chỉ khác nhau đúng một hành vi (tính phí, sắp xếp, validate, render, export format).
- Bạn cần đổi hành vi của một object lúc đang chạy mà không dựng lại object.
- Một hàm chứa
if/elsehoặcswitchlớn mà mỗi nhánh chỉ là một công thức khác nhau. - Bạn muốn thuật toán test độc lập, hoặc cho phép người dùng/admin chọn thuật toán qua config.
- Cần nhiều mức chi tiết của cùng một logic: bản nhanh cho preview, bản chính xác cho báo cáo cuối ngày.
Đừng dùng khi
- Over-engineering. Hai nhánh
if/elsevà bạn chắc chắn nó đứng yên 3 năm? Đừng dựng 5 file + 1 interface. Strategy đáng giá khi số nhánh đã ≥ 3 và còn tăng. - Pattern này làm số lượng class tăng. Một module 3 file biến thành 12 file — phải đánh đổi bằng cách đặt chung folder và đặt tên nhất quán.
- Khách hàng (client) phải biết chiến lược nào khác nhau ở đâu để mà chọn. Nếu việc chọn là nghiệp vụ phức tạp, hãy đưa quyết định đó vào một hàm/Service riêng, đừng để UI tự chọn.
- Trong JS, closure dễ biến chiến lược thành "hàm giữ state âm thầm". Giữ chiến lược thuần (pure) nếu có thể, nếu không thì đặt tên cho rõ.
- Đừng nhét I/O (gọi API lấy tỷ giá) vào trong một chiến lược tính phí rồi coi nó là pure function — bạn sẽ khóc lúc test.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
array.sort(comparator)
Cái comparator chính là chiến lược sắp xếp. Cùng một engine sort, hành vi khác nhau hoàn toàn theo function bạn truyền vào. Đây là Strategy thuần tuý nhất tồn tại trong JS.
addEventListener(type, handler)
Hệ thống event là Strategy ở quy mô lớn: một "ngữ cảnh" (DOM/event loop) gọi hành vi do người khác cung cấp, không cần biết handler làm gì.
Intl.NumberFormat / Intl.Collator
Bạn đưa locale (một "cấu hình chiến lược") và cùng một hàm format() cho ra kết quả khác nhau theo văn hoá.
Layer service trong Nuxt/Node
exportPayment(order, gateway), sendNotification(msg, channel) với map { email, sms, webpush }: registry của Strategy. Thêm kênh mới không đụng code cũ.
08 — Tự tay làm
Bài tập
Viết lại `renderReport(rows, format)` hiện đang có `if (format === "csv") ... else if (format === "json") ... else if (format === "md") ...` thành Strategy, và thêm được định dạng `html` mà không sửa `renderReport`.
Gợi ý, mở từng cái một:
- Hợp đồng là gì? Đầu vào/đầu ra của một "định dạng"?
- Mỗi định dạng một object
{ name, render(rows): string }. - Dùng
Record<string, RenderStrategy>để tra theoformat, và fallback vềcsvnếu không tìm thấy.
Khai báo interface RenderStrategy { name, render(rows) }, tách mỗi nhánh thành một object, thay cây if/else bằng registry[format] ?? registry.csv. Thêm html = thêm một object + một dòng registry.
type Row = Record<string, string | number>
interface RenderStrategy { name: string, render(rows: Row[]): string }
const csv: RenderStrategy = {
name: 'csv',
render: rows => {
const head = Object.keys(rows[0] ?? {}).join(',')
return [head, ...rows.map(r => Object.values(r).join(','))].join('\n')
},
}
const json: RenderStrategy = { name: 'json', render: rows => JSON.stringify(rows) }
const html: RenderStrategy = { // <- file/định dạng MỚI, không sửa renderReport
name: 'html',
render: rows => `<table><tbody>${rows.map(r => `<tr>${Object.values(r).map(v => `<td>${v}</td>`).join('')}</tr>`).join('')}</tbody></table>`,
}
const registry: Record<string, RenderStrategy> = { csv, json, html }
const renderReport = (rows: Row[], format: string) =>
(registry[format] ?? registry.csv).render(rows)
console.log(renderReport([{ a: 1, b: 2 }], 'html'))09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- StateCode giống hệt nhau — Strategy nói "chọn thuật toán", State nói "trạng thái quyết định hành vi và tự chuyển trạng thái". Đọc cặp này để hiểu ý nghĩa quan trọng hơn cấu trúc.
- CommandStrategy tham số hoá *cách làm*; Command gói *việc cần làm* thành object để xếp hàng, undo, log.
- Template MethodCùng mục đích (thay một bước của thuật toán) nhưng Template Method làm bằng inheritance, Strategy làm bằng composition — Strategy linh hoạt hơn vì đổi được lúc chạy.
- DecoratorCùng là composition. Decorator *bọc thêm* hành vi, Strategy *thay* hành vi.