👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Các anti-pattern thường gặp và cách tránh: 7 cạm bẫy quen mặt trong code

TL;DR: Anti-pattern là một "lời giải" trông hợp lý, hay được dùng, nhưng thực ra gây hại nhiều hơn lợi. Bài này điểm 7 cái quen mặt nhất: God Object, Spaghetti code, Golden Hammer, Copy-paste programming, Magic numbers/strings, Premature optimization và Lava flow. Với mỗi cái tôi nêu triệu chứng để bạn nhận diện và cách tránh. Điểm chung: gần như tất cả đều được "chữa" bằng SOLID, DRY, KISS và YAGNI.

Suốt series này bạn đã học các pattern, tức là những lời giải tốt được đúc kết. Bài khép lại này đi theo hướng ngược: các anti-pattern, những lời giải nghe có vẻ ổn nhưng lại kéo dự án xuống. Biết mặt chúng cũng quan trọng ngang biết pattern, vì phần lớn nợ kỹ thuật (technical debt) sinh ra từ đây.

Anti-pattern là gì

Một anti-pattern (phản mẫu) là cách làm lặp đi lặp lại, trông như giải quyết được vấn đề, nhưng về lâu dài lại tạo ra hậu quả xấu. Nó khác với một lỗi (bug) ở chỗ: bug là code chạy sai, còn anti-pattern là code chạy đúng nhưng khó sống chung. Nó khó đọc, khó sửa, khó mở rộng, và thường lôi kéo thêm anti-pattern khác.

Điểm nguy hiểm là anti-pattern hiếm khi do ai đó cố tình làm bậy. Nó xuất hiện từ những quyết định hợp lý trong ngắn hạn: copy một đoạn cho nhanh, nhét thêm một method vào class sẵn có, hardcode một con số để kịp deadline. Từng bước một thì vô hại, gộp lại theo thời gian thành một mớ khó gỡ. Vì vậy cách tốt nhất để tránh là nhận diện sớm, khi chúng còn nhỏ.

Đừng biến bài này thành danh sách để đi soi người khác. Mục tiêu là nhận ra các dấu hiệu trong chính code của bạn và sửa dần. Không có codebase nào sạch tuyệt đối; quan trọng là bạn thấy được cơn đau và biết hướng chữa.
Một lưu ý về thuật ngữ, để bạn dùng từ cho chặt. Theo nghĩa hẹp, anti-pattern là một "lời giải" có tên tuổi, được dùng lặp đi lặp lại cho một loại vấn đề, nhưng hậu quả lại xấu hơn lợi ích. God Object, Golden Hammer, Lava flow là ví dụ đúng nghĩa. Trong khi đó Magic numbers và Premature optimization thường được xếp vào nhóm code smell hoặc thói quen xấu (bad practice) hơn là anti-pattern theo nghĩa chặt. Bài này vẫn gom chung lại vì mục tiêu thực dụng là nhận diện và tránh, nhưng tôi nói rõ ranh giới để bạn khỏi lẫn khi trao đổi trong nhóm hoặc khi đi phỏng vấn.

God Object (class ôm quá nhiều trách nhiệm)

Định nghĩa: một class (hoặc module) biết quá nhiều và làm quá nhiều thứ. Nó thường tên chung chung như Manager, Helper, Utils, System và dài hàng nghìn dòng.

Triệu chứng: mở file ra phải cuộn mãi; class có vài chục method chẳng liên quan gì nhau (vừa gọi database, vừa gửi email, vừa xử lý logic nghiệp vụ, vừa format chuỗi); sửa một tính năng nhỏ cũng phải đụng vào đây và ai cũng sợ đụng vì dễ vỡ chỗ khác.

Vì sao hại: class gánh mọi thứ thì mọi thay đổi đều dồn về một chỗ, dẫn tới coupling cao, test gần như bất khả thi (muốn test một mảnh phải dựng cả thế giới), và nhiều người sửa cùng file gây xung đột liên tục.

Cách tránh: áp dụng Single Responsibility Principle (chữ S trong SOLID): mỗi class chỉ nên có một lý do để thay đổi. Khi thấy một class phình ra, hãy hỏi "class này đang làm mấy việc?" rồi tách mỗi việc thành một class riêng. Ví dụ before/after ở cuối bài minh hoạ đúng thao tác tách này.

Spaghetti code (luồng rối như mì)

Định nghĩa: code không có cấu trúc rõ ràng, luồng điều khiển nhảy loạn xạ, mọi thứ dính vào nhau như đĩa mì rối.

Triệu chứng: hàm dài, lồng if/else nhiều tầng; biến toàn cục dùng khắp nơi; đọc một đoạn phải nhảy qua lại mười chỗ mới hiểu; không tách được đâu là tầng giao diện, đâu là logic, đâu là dữ liệu.

Vì sao hại: bạn không thể suy luận về từng phần một cách độc lập. Sửa chỗ này vỡ chỗ kia vì mọi thứ ngầm phụ thuộc lẫn nhau. Người mới vào gần như không thể đọc hiểu.

Cách tránh: chia code thành các hàm/module nhỏ, mỗi cái làm một việc và có tên nói rõ nó làm gì. Tách các tầng (giao diện, nghiệp vụ, dữ liệu) rành mạch. Hạn chế trạng thái toàn cục. Đây chính là tinh thần KISS (Keep It Simple): ưu tiên luồng thẳng, dễ đọc thay vì khôn khéo mà rối.

Golden Hammer (một búa nện mọi cái đinh)

Định nghĩa: "Khi bạn chỉ có một cái búa, mọi thứ trông đều giống cái đinh." Bạn quen một công cụ, một ngôn ngữ hay một pattern rồi ép nó vào mọi bài toán, kể cả khi không hợp.

Triệu chứng: mọi vấn đề đều được giải bằng đúng một cách; nhét design pattern vào chỗ không cần (một CRUD đơn giản mà có Factory, Strategy, Observer chồng lên nhau); chọn database hay framework theo thói quen chứ không theo nhu cầu bài toán.

Vì sao hại: công cụ sai chỗ làm giải pháp phức tạp hơn mức cần thiết. Bạn trả giá bằng code khó hiểu và hiệu năng kém chỉ để thoả mãn thói quen.

Cách tránh: xuất phát từ bài toán, không từ công cụ. Hỏi "cái này thật sự cần gì?" trước khi chọn cách giải. Chính series này đã nhắc đi nhắc lại: chỉ dùng pattern khi cơn đau đã xuất hiện, đừng nhét pattern cho sang. Lạm dụng Singleton là ví dụ kinh điển của Golden Hammer, đã bàn kỹ ở bài Singleton là gì và vì sao hay bị làm sai.

Copy-paste programming (lặp code)

Định nghĩa: giải quyết nhu cầu mới bằng cách copy một đoạn code cũ rồi sửa vài dòng, thay vì tách phần chung ra dùng lại.

Triệu chứng: cùng một khối logic xuất hiện ở nhiều nơi gần như y hệt; sửa một bug phải đi tìm và sửa ở năm chỗ khác nhau; và thường bạn quên mất một chỗ.

Vì sao hại: mỗi bản copy là một chỗ phải bảo trì riêng. Khi logic thay đổi, các bản dễ trôi ra khác nhau, sinh bug âm thầm. Đây là kẻ thù trực tiếp của nguyên tắc DRY (Don't Repeat Yourself).

Cách tránh: khi định copy lần thứ hai, hãy dừng lại và tách phần chung thành một hàm/class dùng chung. Nhưng đừng cực đoan: hai đoạn trông giống nhau chưa chắc cùng một lý do tồn tại. Gộp bừa hai thứ tình cờ giống nhau lại tạo ra coupling sai. Chỉ gộp khi chúng thật sự là một khái niệm.

Magic numbers / strings (số và chuỗi cứng không tên)

Định nghĩa: các con số hoặc chuỗi được viết thẳng vào code mà không có tên giải thích ý nghĩa, ví dụ if status == 3 hay total * 0.08.

Triệu chứng: đọc code thấy những con số bí ẩn không rõ ở đâu ra; cùng một giá trị (như thuế suất) rải rác nhiều nơi; muốn đổi phải dò tìm và sửa từng chỗ, dễ sót.

Vì sao hại: người đọc không hiểu 0.08 nghĩa là gì (thuế? phí? chiết khấu?). Khi giá trị đổi, bạn phải sửa nhiều nơi và rất dễ bỏ quên một chỗ, tạo bug lệch dữ liệu.

Cách tránh: đặt tên cho giá trị bằng một hằng số (constant) rõ nghĩa, khai báo một chỗ. Vừa đọc hiểu ngay, vừa đổi một chỗ áp dụng toàn bộ. Đây là ví dụ before/after tôi sẽ chạy thật ở dưới.

Premature optimization (tối ưu quá sớm)

Định nghĩa: tối ưu hiệu năng cho một đoạn code trước khi biết nó có thật sự chậm hay không. Câu nói nổi tiếng của Donald Knuth: "premature optimization is the root of all evil" (tối ưu quá sớm là cội nguồn của mọi tai hoạ).

Triệu chứng: viết code khó hiểu, dùng thủ thuật khôn lỏi để "chạy nhanh" ở những chỗ chẳng ai gọi tới nhiều; dựng cache, đánh index, gom batch cho phần vốn không phải điểm nghẽn; dành hàng giờ tối ưu một hàm chạy mỗi ngày một lần.

Vì sao hại: bạn đánh đổi thứ quý nhất (sự đơn giản, dễ đọc) để lấy tốc độ ở nơi không cần, trong khi điểm nghẽn thật sự vẫn nằm đâu đó chưa ai đo. Code khó hiểu hơn mà tổng thể chẳng nhanh hơn.

Cách tránh: viết code rõ ràng, đúng trước đã. Khi nghi ngờ chậm thì đo (profiling) để tìm điểm nghẽn thật, rồi mới tối ưu đúng chỗ đó. Đây là tinh thần YAGNI (You Aren't Gonna Need It): đừng làm thứ chưa cần. Lưu ý: chọn đúng thuật toán/cấu trúc dữ liệu ngay từ đầu không phải premature optimization, đó là thiết kế đúng.

Lava flow (code chết không ai dám xoá)

Định nghĩa: những đoạn code cũ, không còn dùng hoặc không ai hiểu, nhưng vẫn nằm lại trong dự án vì "không rõ xoá đi có vỡ gì không". Giống dung nham nguội lại thành đá, cứng ngắc và chắn đường.

Triệu chứng: hàm không nơi nào gọi vẫn còn đó; những khối code bị comment lại "để phòng khi cần"; biến, config, flag không ai nhớ để làm gì; comment kiểu "đừng đụng vào, không hiểu sao nhưng nó cần".

Vì sao hại: code chết làm nhiễu, khiến người đọc mất thời gian hiểu thứ vô dụng, và làm mọi thay đổi rủi ro hơn vì không ai chắc phần nào còn sống. Nó tích tụ dần cho tới khi không ai dám động vào cả module.

Cách tránh: mạnh dạn xoá code chết. Bạn có version control (git) để phục hồi nếu cần, nên không việc gì phải giữ code trong file cho "an tâm". Có test và review giúp bạn xoá tự tin hơn. Nguyên tắc: nếu không dùng, hãy xoá; đừng comment lại rồi để đó.

Ví dụ before/after (chạy được)

Hãy lấy một hàm tính lương thực nhận. Bản before dính hai anti-pattern cùng lúc: Magic numbers (những con số 40, 0.08, 50000, 0.1 không tên) và God Function (một hàm ôm cả tính lương lẫn tính thuế):

# BEFORE: magic numbers rai rac, mot ham om moi thu
def tinh_tien(gio_luong, so_gio):
    luong = gio_luong * so_gio
    if so_gio > 40:
        luong += gio_luong * (so_gio - 40) * 0.5
    thue = luong * 0.08
    if luong > 50000:
        thue += (luong - 50000) * 0.1
    return luong - thue

print(round(tinh_tien(100, 45), 2))
4370.0

Code chạy đúng, nhưng đọc vào bạn không biết 0.08 là thuế hay phí, 40 là số giờ chuẩn hay gì. Muốn đổi thuế suất phải dò trong thân hàm. Bản after đặt tên cho từng giá trị và tách trách nhiệm ra ba hàm nhỏ, mỗi hàm một việc:

GIO_CHUAN_TUAN = 40
HE_SO_TANG_CA = 0.5
THUE_SUAT_CO_BAN = 0.08
NGUONG_THUE_CAO = 50000
THUE_SUAT_CAO = 0.1

def luong_gross(gio_luong, so_gio):
    luong = gio_luong * so_gio
    if so_gio > GIO_CHUAN_TUAN:
        gio_tang_ca = so_gio - GIO_CHUAN_TUAN
        luong += gio_luong * gio_tang_ca * HE_SO_TANG_CA
    return luong

def tien_thue(luong):
    thue = luong * THUE_SUAT_CO_BAN
    if luong > NGUONG_THUE_CAO:
        thue += (luong - NGUONG_THUE_CAO) * THUE_SUAT_CAO
    return thue

def luong_thuc_nhan(gio_luong, so_gio):
    luong = luong_gross(gio_luong, so_gio)
    return luong - tien_thue(luong)

print(round(luong_thuc_nhan(100, 45), 2))
4370.0

Cùng kết quả 4370.0, nhưng bản after đọc là hiểu: đâu là quy tắc tăng ca, đâu là quy tắc thuế. Đổi thuế suất chỉ sửa một hằng số. Muốn test riêng phần tính thuế thì gọi thẳng tien_thue mà không cần dựng cả phép tính lương. Một thao tác nhỏ nhưng gỡ được đúng hai anti-pattern quen mặt.

Phát hiện sớm bằng công cụ và quy trình

Bảy thứ ở trên hiếm khi xuất hiện trọn vẹn trong một lần commit. Chúng lớn dần, mỗi ngày một chút. Nên cách rẻ nhất là để máy canh giúp bạn, thay vì trông chờ vào trí nhớ con người lúc review.

  • Linter chạy tự động trong CI. ruff, flake8 hay pylint bắt được code chết, biến khai báo rồi không dùng, import thừa, hàm vượt ngưỡng phức tạp. Kèm formatter để khỏi cãi nhau về style. Quan trọng là đặt chúng ở bước bắt buộc của pipeline, không phải thứ tuỳ tâm ai nhớ thì chạy ở máy mình.
  • Đo độ phức tạp vòng lặp (cyclomatic complexity). Dùng radon hoặc bật quy tắc C901 (max-complexity) để chặn hàm và class phình quá mức. Con số này nhích lên đều đặn là tín hiệu sớm của God Object và Spaghetti code, thường xuất hiện trước khi mắt người kịp thấy file đã dài quá.
  • Đo độ phủ test (coverage). Vùng không có test thường trùng đúng với vùng không ai dám sửa, và đó chính là mầm mống của Lava flow. Đọc báo cáo coverage để biết phần nào của hệ thống đang bị bỏ rơi.
  • Kiểm tra trùng lặp mã. jscpd, hoặc tính năng duplication của SonarQube, cho bạn thấy Copy-paste programming khi nó mới có hai ba bản, trước lúc kịp lan ra khắp dự án.
  • Quy trình, không chỉ công cụ. Một checklist ngắn khi review code (hàm này đang làm mấy việc? con số này đã có tên chưa? đoạn cũ kia còn ai gọi không?) và một quy ước dứt khoát: xoá code chết ngay thay vì comment lại để đó. Git đã nhớ hộ bạn rồi.
  • Riêng với Premature optimization. Đặt luật: phải có số đo (profile hoặc benchmark) trước khi tối ưu, và số đo đó đi kèm trong mô tả pull request. Đây là cách rẻ nhất để chặn nó, vì phần lớn tối ưu quá sớm không sống nổi qua một câu hỏi duy nhất: "đo ở đâu?".

Công cụ không thay được người đọc code, nhưng nó biến những thứ mơ hồ thành con số cụ thể chạy trong pipeline mỗi lần push. Mà cơn đau lúc còn nhỏ luôn là cơn đau rẻ nhất để chữa.

Tóm tắt: nguyên tắc chung để tránh

Nhìn lại cả 7 cái, bạn sẽ thấy chúng không cần 7 liều thuốc khác nhau. Vài nguyên tắc nền tảng đã chữa gần hết:

  • SOLID, đặc biệt Single Responsibility, là thuốc cho God Object và Spaghetti code: mỗi thứ một trách nhiệm, phụ thuộc vào abstraction thay vì chi tiết cụ thể.
  • DRY chặn Copy-paste programming: một tri thức chỉ nên có một nơi định nghĩa. Đặt hằng số có tên cũng là một dạng DRY cho các giá trị.
  • KISS (Keep It Simple) đẩy lùi Golden Hammer và Spaghetti: chọn cách đơn giản nhất giải được bài toán, đừng khôn khéo quá mức.
  • YAGNI (You Aren't Gonna Need It) chặn Premature optimization và cả việc nhét pattern bừa: chỉ làm khi thật sự cần, đo trước khi tối ưu. Mặt trái của việc nhét pattern bừa đã bàn riêng ở bài Over-engineering: khi design pattern hại nhiều hơn lợi.
  • Với Lava flow: hãy tin vào git và test, mạnh dạn xoá thứ không dùng.

Nói ngắn gọn: anti-pattern thường là hệ quả của việc bỏ qua các nguyên tắc thiết kế cơ bản. Nắm chắc SOLID, DRY, KISS, YAGNI thì bạn tránh được phần lớn chúng một cách tự nhiên, không cần thuộc lòng từng cái tên.

Series Design Patterns - bài khép lại. Đây là bài cuối của lộ trình Design Patterns. Nếu anti-pattern là những cạm bẫy, thì nền tảng để tránh chúng nằm ở SOLID và DRY, còn bản chất của pattern thì xem lại ở Design Pattern là gì?. Toàn bộ lộ trình nằm ở mục lục Design Patterns. Cảm ơn bạn đã theo hết series; giờ thì đi viết code sạch hơn thôi.

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét