interpret() đệ quy là bạn chạy được câu lệnh của ngôn ngữ đó. Lợi ích lớn nhất: luật nghiệp vụ trở thành dữ liệu, sửa được mà không phải deploy lại. Nhưng đây là mẫu ít dùng nhất trong 23 mẫu GoF: ngữ pháp vừa lớn lên một chút là số class bùng nổ, và lúc đó một thư viện parser thật sự tốt hơn nhiều.Có một loại yêu cầu mà dev nào làm sản phẩm cũng gặp: "cho phép đội marketing tự đổi điều kiện khuyến mãi", "cho phép bật tính năng cho nhóm người dùng theo tiêu chí tự đặt". Nói cách khác, luật thay đổi liên tục và người đổi luật không phải bạn. Interpreter là câu trả lời của Gang of Four cho tình huống này: thay vì hardcode từng luật, bạn dựng hẳn một ngôn ngữ nhỏ để diễn đạt luật. Bài này đi từ gốc: ngữ pháp là gì, cây cú pháp hình thành ra sao, và vì sao tôi vẫn khuyên bạn cân nhắc rất kỹ trước khi tự viết một cái.
Interpreter pattern là gì
Interpreter thuộc nhóm Behavioral (hành vi). Định nghĩa của GoF: cho một ngôn ngữ, định nghĩa biểu diễn cho ngữ pháp của nó cùng một bộ thông dịch (interpreter) dùng biểu diễn đó để diễn giải các câu trong ngôn ngữ.
Dịch sang ngôn ngữ đời thường, pattern này gồm ba phần:
- Ngữ pháp (grammar): tập luật mô tả câu hợp lệ của ngôn ngữ nhỏ đó. Ví dụ "một điều kiện là: một so sánh, hoặc hai điều kiện nối bằng AND/OR".
- Mỗi luật ngữ pháp thành một class. Luật không chứa luật con gọi là biểu thức terminal (lá, ví dụ một biến hay một hằng số); luật chứa luật con gọi là non-terminal (ví dụ AND, OR, phép so sánh).
- Một method chung, thường đặt tên
interpret(context). Node lá trả về giá trị; node ghép gọiinterpret()của các con rồi kết hợp kết quả. Đệ quy tự nhiên từ gốc xuống lá.
Analogy tôi thấy sát nhất: một ngôn ngữ mini nội bộ trong sản phẩm của bạn. Giống ô "công thức" trong Excel hay ô "điều kiện" trong một công cụ gửi email marketing: người dùng gõ age > 18 AND country == "VN", phần mềm hiểu và chạy được, mà họ không cần biết lập trình. Bạn là người định ra ngôn ngữ đó nhỏ tới đâu, gồm những gì.
Để ý cấu trúc cây ở đây: một node AND chứa hai node con, mỗi node con lại có thể là một node ghép khác. Đó chính là Composite pattern đội lốt. Interpreter gần như luôn được cài đặt trên nền một cây Composite, chỉ khác ở chỗ method chung mang ý nghĩa "diễn giải" thay vì "tính kích thước" hay "vẽ ra màn hình".
Vấn đề: luật nghiệp vụ hardcode bằng if/elif
Bắt đầu bằng cách ai cũng làm. Một hàm lọc người dùng cho chiến dịch khuyến mãi:
def eligible(user, campaign):
if campaign == "tet_2026":
return user["age"] > 18 and user["country"] == "VN"
elif campaign == "summer_jp":
return user["country"] == "JP" and user["orders"] >= 3
elif campaign == "vip_only":
return user["tier"] == "vip" or user["spent"] > 10_000_000
return False
Chạy được, đọc được. Vấn đề không nằm ở code, nằm ở quy trình quanh nó:
- Mỗi chiến dịch mới là một lần sửa code và deploy. Đội marketing nghĩ ra điều kiện lúc 5 giờ chiều thứ sáu, bạn phải mở IDE. Luật nghiệp vụ bị nhốt trong file Python.
- Luật không phải là dữ liệu. Bạn không thể lưu nó vào database, không thể cho người dùng xem lại, không thể so sánh hai phiên bản luật, không thể audit ai đổi gì.
- Khối điều kiện phình theo thời gian. Sáu tháng sau hàm này có 40 nhánh, trong đó vài nhánh của chiến dịch đã kết thúc từ lâu mà không ai dám xoá.
- Test tốn công. Muốn kiểm tra một điều kiện con, bạn phải gọi cả hàm với đúng tên chiến dịch.
Điểm chung: luật đang nằm ở dạng code, trong khi bản chất nó là dữ liệu hay thay đổi. Interpreter đổi chỗ hai thứ đó.
Cách hoạt động: mỗi luật ngữ pháp một class
Ta dựng một ngôn ngữ nhỏ chỉ đủ diễn đạt điều kiện boolean. Ngữ pháp vỏn vẹn vài luật: một biểu thức là hằng số, biến, phép so sánh (>, ==), hoặc phép nối logic (AND, OR, NOT). Mỗi luật thành một class, tất cả cài chung method interpret(ctx) với ctx là ngữ cảnh (context) chứa dữ liệu người dùng:
from abc import ABC, abstractmethod
class Expr(ABC): # moi luat ngu phap = mot class
@abstractmethod
def interpret(self, ctx): ...
# --- bieu thuc la (terminal): khong chua bieu thuc con ---
class Var(Expr): # lay gia tri tu context
def __init__(self, name): self.name = name
def interpret(self, ctx): return ctx[self.name]
class Const(Expr): # hang so viet thang trong luat
def __init__(self, value): self.value = value
def interpret(self, ctx): return self.value
# --- bieu thuc ghep (non-terminal): chua bieu thuc con ---
class GreaterThan(Expr):
def __init__(self, left, right): self.left, self.right = left, right
def interpret(self, ctx):
return self.left.interpret(ctx) > self.right.interpret(ctx)
class Equals(Expr):
def __init__(self, left, right): self.left, self.right = left, right
def interpret(self, ctx):
return self.left.interpret(ctx) == self.right.interpret(ctx)
class And(Expr):
def __init__(self, left, right): self.left, self.right = left, right
def interpret(self, ctx):
return self.left.interpret(ctx) and self.right.interpret(ctx)
class Or(Expr):
def __init__(self, left, right): self.left, self.right = left, right
def interpret(self, ctx):
return self.left.interpret(ctx) or self.right.interpret(ctx)
class Not(Expr):
def __init__(self, inner): self.inner = inner
def interpret(self, ctx): return not self.inner.interpret(ctx)
Tám class, mỗi class vài dòng. Giờ dựng cây cú pháp cho luật age > 18 AND country == "VN" và chạy nó với vài ngữ cảnh khác nhau:
# Cay cu phap cho luat: age > 18 AND country == "VN"
rule = And(
GreaterThan(Var("age"), Const(18)),
Equals(Var("country"), Const("VN")),
)
users = [
{"name": "An", "age": 25, "country": "VN"},
{"name": "Bao", "age": 16, "country": "VN"},
{"name": "Cuong", "age": 30, "country": "JP"},
]
print("Luat: age > 18 AND country == VN")
for u in users:
print(" ", u["name"], ":", rule.interpret(u))
# Ghep them mot tang nua, khong sua class nao het:
# (age > 18 AND country == "VN") OR NOT(country == "VN")
rule2 = Or(rule, Not(Equals(Var("country"), Const("VN"))))
print("Luat 2: luat cu OR khach ngoai VN")
for u in users:
print(" ", u["name"], ":", rule2.interpret(u))
Ba điều đáng chú ý trong kết quả:
- Cây tự diễn giải chính nó. Gọi
rule.interpret(u)một lần, nodeAndgọi xuống hai con,GreaterThanlại gọi xuốngVarvàConst. Không có vòng lặp nào điều phối, đệ quy lo hết. - Luật ghép được tuỳ ý.
rule2tái sử dụng nguyênrulelàm một nhánh con, chỉ bọc thêmOrvàNot. Không class nào phải sửa. Đây đúng là chỗ Interpreter thừa hưởng sức mạnh của cây Composite. - Ngữ cảnh tách khỏi luật. Cùng một cây chạy với ba context khác nhau cho ba kết quả khác nhau. Luật là cấu trúc, dữ liệu đi vào lúc gọi.
Bước quyết định: luật trở thành dữ liệu
Đến đây luật vẫn nằm trong code Python, chỉ khác là nằm ở dạng cây thay vì if. Giá trị thật xuất hiện khi bạn thêm một hàm dựng cây từ dữ liệu ngoài, ví dụ JSON lưu trong database:
import json
OPS = {"and": And, "or": Or, "gt": GreaterThan, "eq": Equals}
def build(node): # dich JSON thanh cay cu phap
if "var" in node: return Var(node["var"])
if "const" in node: return Const(node["const"])
if "not" in node: return Not(build(node["not"]))
op, (a, b) = node["op"], node["args"]
return OPS[op](build(a), build(b))
raw = """
{"op": "and", "args": [
{"op": "gt", "args": [{"var": "age"}, {"const": 18}]},
{"op": "eq", "args": [{"var": "country"}, {"const": "VN"}]}
]}
"""
rule = build(json.loads(raw)) # luat nam trong file cau hinh, khong nam trong code
print(rule.interpret({"age": 25, "country": "VN"}))
print(rule.interpret({"age": 16, "country": "VN"}))
Giờ đội marketing đổi 18 thành 21 trong giao diện quản trị, bản ghi JSON trong database đổi theo, luật đổi ngay lập tức. Không sửa code, không deploy. Đó mới là lý do người ta chịu bỏ công dựng Interpreter.
build ở trên là một parser rất thô: nó chỉ đọc cấu trúc JSON đã phân cấp sẵn. Nếu bạn muốn nhận luật ở dạng chuỗi tự do như age > 18 AND country == "VN", bạn cần thêm một bộ phân tích cú pháp thực thụ (tách token, xử lý độ ưu tiên toán tử, dấu ngoặc). GoF cố tình không nói tới phần đó: Interpreter chỉ lo diễn giải cây đã có, còn dựng cây từ chuỗi là chuyện khác. Nhiều người vỡ mộng với pattern này chính vì không nhận ra khoảng trống đó.Trong hệ thống thật
Bạn hiếm khi thấy ai nói "tôi dùng Interpreter pattern", nhưng tinh thần của nó có mặt ở khá nhiều chỗ quen thuộc:
- Bộ lọc truy vấn (query filter DSL). Các API kiểu
?filter[status]=active&filter[age][gt]=18, hay phần "Advanced search" cho người dùng ghép nhiều điều kiện bằng AND/OR trên giao diện. Phía server, bộ lọc đó thường được dựng thành cây node rồi dịch xuống câu WHERE hoặc chạy trực tiếp trên dữ liệu. - Luật feature flag và phân khúc người dùng (user segmentation). Các nền tảng feature flag cho bạn khai báo điều kiện kiểu "bật cho user ở VN, gói premium, đăng ký sau tháng 6". Điều kiện được lưu dạng dữ liệu, tải về SDK, rồi đánh giá cục bộ với context của từng request. Đúng mô hình node cộng
interpret(context). - Công thức tính giá và khuyến mãi cấu hình được. Hệ thống bán hàng thường cần "giảm 10% cho đơn trên 500k, cộng dồn tối đa 2 mã, trừ nhóm hàng điện tử". Nhốt mấy luật đó trong code là tự chuốc khổ; biểu diễn chúng thành cây biểu thức cho phép đội vận hành tự sửa.
- Template engine. Jinja2, Handlebars hay bộ template của Django đều phân tích chuỗi template thành cây node (text tĩnh, biến, vòng lặp, điều kiện) rồi duyệt cây để render. Một node
{% if %}chính là một non-terminal chứa các node con. - Biểu thức quyền (policy expression). IAM policy của các nhà cung cấp cloud, hay các engine kiểu Open Policy Agent, đều là ngôn ngữ nhỏ mô tả điều kiện cho phép, được đánh giá trên một context (ai, làm gì, với tài nguyên nào, trong hoàn cảnh nào).
Điểm chung của cả năm: người viết luật không phải người viết code, và luật cần sống lâu hơn một lần deploy.
Trade-off
Được:
- Người không phải dev cũng đổi được luật. Luật nằm ở database hay file cấu hình, sửa qua giao diện quản trị, hiệu lực ngay.
- Luật trở thành dữ liệu. Lưu được, version được, so sánh được, audit được ai đổi gì lúc nào. Thứ mà một khối
if/elifkhông bao giờ cho bạn. - Dễ test từng node.
GreaterThanlà một class độc lập vài dòng, test nó không cần dựng cả hệ thống. Cây lớn thì test theo kiểu ghép dần. - Mở rộng ngữ pháp không đụng code cũ. Thêm toán tử
InhayBetweenchỉ là thêm một class và một dòng trong bảngOPS.
Phải trả giá:
- Mỗi luật ngữ pháp một class, ngữ pháp phình thì số class phình. Ví dụ trên chỉ có 5 toán tử đã cần 8 class. Một ngôn ngữ biểu thức đầy đủ (số học, chuỗi, ngày tháng, hàm, độ ưu tiên) dễ dàng vượt 50 class.
- Hiệu năng kém hơn code thẳng. Mỗi lần đánh giá là một chuỗi lời gọi method đệ quy cộng cấp phát đối tượng, thay vì một phép so sánh. Với luật chạy trên vài triệu bản ghi, khác biệt này là thật.
- Ngữ pháp lớn là ác mộng bảo trì. Sửa độ ưu tiên toán tử hay thêm dấu ngoặc lồng nhau sẽ đụng vào nhiều class cùng lúc. Lỗi ở tầng ngữ pháp rất khó debug vì lỗi lộ ra ở tận node lá.
- Rủi ro bảo mật nếu bạn đi tắt. Cám dỗ lớn nhất là bỏ qua cả pattern và gọi thẳng
eval()trên chuỗi luật do người dùng nhập. Đừng. Đó là lỗ hổng thực thi mã tuỳ ý (arbitrary code execution). Ngay cả khi tự viết interpreter, bạn vẫn phải giới hạn độ sâu cây và thời gian chạy để tránh luật độc hại làm treo tiến trình. - Thiếu công cụ. Ngôn ngữ nhỏ của bạn không có syntax highlight, không có báo lỗi tử tế, không có autocomplete. Người dùng gõ sai một chữ và nhận về một thông báo khó hiểu.
Khi nào KHÔNG nên tự viết Interpreter
days_since(), cần so sánh ngày tháng. Tới lúc đó bạn không còn viết một pattern, bạn đang viết một trình biên dịch nửa vời, thiếu tài liệu và chỉ một người trong đội hiểu. Interpreter chỉ đáng dùng khi ngữ pháp vừa NHỎ vừa ỔN ĐỊNH. Nếu bạn không dám cam kết cả hai chữ đó, dừng lại.Những lựa chọn nên cân nhắc trước:
- Dùng thư viện parser thay vì tự viết. Với Python,
larkhayplycho phép bạn khai báo ngữ pháp bằng vài chục dòng EBNF rồi tự sinh parser, kèm báo lỗi cú pháp tử tế. Bạn vẫn giữ phần đánh giá dạng cây (đúng tinh thần Interpreter), nhưng không phải tự tay viết bộ phân tích cú pháp, là phần tốn công và dễ sai nhất. - Mượn luôn ngữ pháp của Python. Module
asttrong thư viện chuẩn parse sẵn biểu thức Python thành cây. Bạn duyệt cây đó và chỉ cho phép một tập node an toàn (so sánh, boolean, hằng số, tên biến trong whitelist), chặn mọi thứ còn lại. Cách này cho bạn một ngôn ngữ đầy đủ mà không tốn một dòng parser. Điều kiện bắt buộc: phải whitelist, không được blacklist, và tuyệt đối không dùngeval()trên cây chưa kiểm duyệt. - Chọn một engine luật có sẵn. Nếu nhu cầu là feature flag hay phân khúc người dùng, các nền tảng sẵn có đã giải quyết cả phần giao diện, phần lưu trữ và phần đánh giá. Tự viết lại chỉ để sở hữu mã nguồn thường là một khoản nợ.
- Hoặc đơn giản là đừng làm gì cả. Nếu chỉ có ba chiến dịch và mỗi quý thêm một cái, khối
if/elifở đầu bài vẫn là câu trả lời đúng. Dựng ngôn ngữ nhỏ cho ba luật là over-engineering kinh điển.
Cách tôi ra quyết định, gọn trong một câu: chỉ dựng ngôn ngữ nhỏ khi người đổi luật không phải là người viết code, và tần suất đổi luật đủ cao để một lần deploy trở thành nút thắt. Không thoả cả hai vế thì Interpreter chỉ là bài tập kiến trúc.
Tóm tắt
- Interpreter định nghĩa ngữ pháp cho một ngôn ngữ nhỏ, biến mỗi luật ngữ pháp thành một class, ghép thành cây cú pháp rồi gọi
interpret(context)đệ quy. - Cấu trúc cây của nó chính là Composite; khác biệt nằm ở ý nghĩa của method chung, ở đây là diễn giải một câu lệnh.
- Giá trị thật không phải ở cái cây, mà ở chỗ luật nghiệp vụ trở thành dữ liệu: lưu được, sửa được qua giao diện, không cần deploy.
- Tinh thần của nó xuất hiện trong bộ lọc truy vấn, luật feature flag, công thức khuyến mãi, template engine và biểu thức quyền.
- Cái giá: số class phình theo ngữ pháp, chạy chậm hơn code thẳng, và ngữ pháp lớn thì cực khó bảo trì. Tuyệt đối không dùng
eval()trên chuỗi luật của người dùng. - Đây là pattern ít dùng nhất trong GoF. Chỉ hợp với ngữ pháp nhỏ và ổn định. Lớn hơn thế, hãy dùng
lark,ply, moduleastcủa Python, hoặc một engine luật có sẵn.
Nguồn tham khảo
- Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương Interpreter, nhóm Behavioral; phần Consequences của chính cuốn sách cũng nói rõ pattern chỉ phù hợp với ngữ pháp đơn giản.
- Tài liệu module
asttrong thư viện chuẩn Python, và tài liệu thư việnlarkcho hướng dùng parser generator thay vì tự viết.
- Kai