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.

Hành vi●○○12 phút đọc8 bướccòn gọi: Policy, Algorithm
thuật toánif elsepluginbehavioraldependency injectionfunction

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

1

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.

tscheckout-v1.ts
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)
  }
}
Mọi kiến thức về vận chuyển đều nằm trong một hàm. else if thứ 5 sẽ đến rất nhanh.
ChốtDấu hiệu của Strategy: một hàm có nhiều nhánh 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ề.
2

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.

tsshipping-strategy.ts
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
}
Interface này là toàn bộ "sự trừu tượng" của pattern. Nó rẻ, và nó đứng yên khi mọi công thức thay đổi.
ChốtStrategy không trừu tượng hoá "toàn bộ class", nó trừu tượng hoá một hành vi cụ thể. Càng cụ thể, interface càng dễ đúng.
3

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.

tsstrategies.ts
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),
}
Chú ý: chiến lược này được test độc lập bằng một hàm thuần tuý, không cần dựng Checkout.
ChốtTest một chiến lược = gọi một hàm. Không mock, không DB, không "setup 40 dòng fixture".
4

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.

tscheckout-v2.ts
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}đ`)
  }
}
Không còn if. Không còn throw new Error("loai khong ton tai") — TypeScript chặn nó ngay tại chỗ gọi.
ChốtNgữ cảnh phụ thuộc vào interface, không phụ thuộc vào implementation. Đó chính là Dependency Injection, và Strategy là dạng cổ điển nhất của nó.
5

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.

tsdemo.ts
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)
console
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đ
6

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.

tsregistry.ts
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')
Thêm loại phí mới = thêm 1 dòng map + 1 file. Không file cũ nào bị sửa. Đó là Open/Closed Principle bằng xương bằng thịt.
7

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:

tsfunction-version.ts
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ược
ChốtDùng interface/class khi chiến lược có state hoặc cần nhiều method. Dùng function khi nó chỉ là một phép tính. Đừng ceremony hoá.
8

Kiể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.

tsnight-shift.ts
// 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': nightShift
Nếu thêm tính năng chỉ tốn "thêm file" chứ không tốn "sửa file cũ", bạn đã đóng (closed) với sửa đổi và mở (open) với phát triển.

04 — 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

tsdemo.ts
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)
console
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/else hoặc switch lớ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/else và 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:

  1. Hợp đồng là gì? Đầu vào/đầu ra của một "định dạng"?
  2. Mỗi định dạng một object { name, render(rows): string }.
  3. Dùng Record<string, RenderStrategy> để tra theo format, và fallback về csv nế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.

tsbai-tap.ts
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.