7 Thói Quen Giúp Bạn Code Sạch Hơn Mỗi Ngày

Giới thiệu

Viết code chạy được là một chuyện, nhưng viết code sạch (Clean Code) lại là một kỹ năng hoàn toàn khác. Trong môi trường làm việc thực tế, lập trình viên dành phần lớn thời gian để đọc, sửa và mở rộng code hơn là viết mới. Vì vậy, chất lượng mã nguồn ảnh hưởng trực tiếp đến tốc độ phát triển sản phẩm, khả năng bảo trì và hiệu quả làm việc của cả đội ngũ.

Nhiều lập trình viên mới thường tập trung vào việc học framework, thư viện hay công nghệ mới mà quên rằng kỹ năng viết code sạch mới là yếu tố giúp họ phát triển lâu dài trong sự nghiệp.

Bài viết này sẽ chia sẻ 7 thói quen đơn giản nhưng cực kỳ hiệu quả giúp bạn cải thiện chất lượng mã nguồn mỗi ngày.

1. Đặt tên biến và hàm có ý nghĩa

Đặt tên là một trong những kỹ năng quan trọng nhất của lập trình viên.

Một cái tên tốt giúp người khác hiểu ngay mục đích của đoạn code mà không cần đọc thêm chú thích.

Ví dụ chưa tốt

 Javascript
1const d = new Date();
2
3function calc(a, b) {
4    return a * b;
5}

Khi nhìn vào đoạn code trên, rất khó biết:

• d dùng để làm gì
• calc() đang tính toán điều gì

Ví dụ tốt hơn

 Javascript
1const currentDate = new Date();
2
3function calculateTotalPrice(quantity, price) {
4    return quantity * price;
5}

Chỉ cần nhìn tên là có thể hiểu chức năng.

Nguyên tắc

Tên nên:

• Mô tả rõ ý nghĩa
• Dễ đọc
• Dễ tìm kiếm
• Thống nhất trong toàn dự án

Nên tránh:

 Javascript
1a
2b
3c
4temp
5data
6test

Trừ những trường hợp đặc biệt như vòng lặp ngắn:

 Javascript
1for (let i = 0; i < 10; i++) {}

2. Viết hàm ngắn và chỉ làm một việc

Một hàm tốt nên chỉ chịu trách nhiệm cho một nhiệm vụ duy nhất.

Đây là nguyên tắc Single Responsibility.

Ví dụ chưa tốt

 Javascript
1function processOrder(order) {
2    validateOrder(order);
3
4    saveOrder(order);
5
6    sendEmail(order);
7
8    updateInventory(order);
9
10    createInvoice(order);
11
12    logActivity(order);
13}

Hàm này đang thực hiện quá nhiều công việc.

Ví dụ tốt hơn

 Javascript
1function processOrder(order) {
2    validateOrder(order);
3
4    saveOrder(order);
5
6    notifyOrderCreated(order);
7}

Trong đó:

 Javascript
1function notifyOrderCreated(order) {
2    sendEmail(order);
3    updateInventory(order);
4    createInvoice(order);
5}

Lợi ích

• Dễ đọc
• Dễ kiểm thử
• Dễ tái sử dụng
• Dễ bảo trì

3. Tránh lặp lại code

Nguyên tắc DRY (Don't Repeat Yourself) là một trong những nguyên tắc quan trọng nhất trong lập trình.

Ví dụ chưa tốt

 Javascript
1const total1 = productPrice1 * quantity1;
2
3const total2 = productPrice2 * quantity2;
4
5const total3 = productPrice3 * quantity3;

Ví dụ tốt hơn

 Javascript
1function calculateTotal(price, quantity) {
2    return price * quantity;
3}

Sử dụng:

 Javascript
1const total1 = calculateTotal(price1, quantity1);
2const total2 = calculateTotal(price2, quantity2);
3const total3 = calculateTotal(price3, quantity3);

Lợi ích

• Giảm số dòng code
• Giảm lỗi
• Dễ sửa đổi

Nếu công thức thay đổi:

 Javascript
1function calculateTotal(price, quantity) {
2    return price * quantity * 0.9;
3}

Chỉ cần sửa một nơi.

4. Xóa code không còn sử dụng

Nhiều lập trình viên có thói quen giữ lại code cũ "phòng khi cần dùng lại".

Điều này khiến codebase ngày càng khó đọc.

Ví dụ

 Javascript
1// Old login function
2// function login() {
3//     ...
4// }

Hoặc:

 Javascript
1const oldData = [];
2const unusedVariable = "test";

Giải pháp

Nếu không còn sử dụng:

 Javascript
1git commit

rồi xóa hẳn.

Git đã lưu lịch sử thay đổi.

Bạn không cần giữ lại code chết trong dự án.

Lợi ích

• Source code gọn hơn
• Dễ đọc hơn
• Giảm nhầm lẫn

5. Luôn format code trước khi commit

Code không chỉ cần đúng mà còn phải dễ đọc.

Ví dụ chưa format

 Javascript
1function getUser(){
2const user={name:"John",age:20}
3return user
4}

Ví dụ đã format

 Javascript
1function getUser() {
2    const user = {
3        name: "John",
4        age: 20
5    };
6
7    return user;
8}

Công cụ nên dùng

Prettier

 Bash
1npm install --save-dev prettier

ESLint

 Bash
1npm install --save-dev eslint

Husky

Tự động kiểm tra trước khi commit.

 Bash
1npm install --save-dev husky

Kết quả

Toàn bộ dự án sẽ có cùng một style code.

6. Luôn review lại code trước khi push

Một thói quen rất nhiều người bỏ qua.

Sau khi hoàn thành tính năng, đừng push ngay.

Hãy dành vài phút đọc lại code.

Tự hỏi

Đoạn code này có dễ hiểu không?

 Javascript
1const x = data.map((a) => ...)

Hay nên đổi thành:

 Javascript
1const mappedUsers = users.map((user) => ...)

Có đoạn code nào bị lặp không?

Ví dụ:

 Javascript
1validateEmail();
2validateEmail();
3validateEmail();

Có thể tách thành helper.

Có biến nào không còn sử dụng không?

 Javascript
1const temp = [];

Nếu không dùng thì xóa.

Lợi ích

Chỉ cần 5 phút review có thể giúp tránh hàng giờ sửa lỗi sau này.

7. Luôn nghĩ đến người đọc code tiếp theo

Người đọc code tiếp theo có thể là:

• Đồng nghiệp
• Người bảo trì hệ thống
• Chính bạn sau 6 tháng

Hoặc thậm chí là người phỏng vấn kỹ thuật.

Ví dụ chưa tốt

 Javascript
1if (a === 1 && b === 2 && c === 3) {
2    ...
3}

Ví dụ tốt hơn

 Javascript
1const isAdminUser =
2    role === "admin" &&
3    status === "active" &&
4    permission === "full";
5
6if (isAdminUser) {
7    ...
8}

Ý nghĩa trở nên rõ ràng hơn rất nhiều.

Hãy luôn tự hỏi

Nếu một người mới vào dự án đọc đoạn code này, họ có hiểu ngay không?

Nếu câu trả lời là "không", hãy cải thiện nó.

Bonus: Học cách Refactor thường xuyên

Refactor là quá trình cải thiện cấu trúc code mà không làm thay đổi hành vi của chương trình.

Ví dụ:

Trước:

 Javascript
1function getUserInfo(user) {
2    return `${user.firstName} ${user.lastName}`;
3}

Sau:

 Javascript
1function getFullName(user) {
2    return `${user.firstName} ${user.lastName}`;
3}

Logic không đổi nhưng tên hàm rõ nghĩa hơn.

Những việc nên refactor thường xuyên

• Đổi tên biến
• Đổi tên hàm
• Tách hàm lớn
• Loại bỏ code trùng lặp
• Loại bỏ code chết
• Chuẩn hóa cấu trúc thư mục

Checklist Clean Code Hằng Ngày

Trước khi commit, hãy tự kiểm tra:

• Biến và hàm đã đặt tên rõ ràng chưa?
• Hàm có đang làm quá nhiều việc không?
• Có đoạn code nào bị lặp lại không?
• Có biến hoặc hàm nào không còn sử dụng không?
• Đã chạy Prettier và ESLint chưa?
• Đã đọc lại code ít nhất một lần chưa?
• Người khác có thể hiểu code này dễ dàng không?

Nếu tất cả câu trả lời đều là "Có", chất lượng mã nguồn của bạn sẽ tốt hơn rất nhiều.

Kết luận

Code sạch không đến từ việc học thêm framework mới hay sử dụng những kỹ thuật phức tạp. Nó đến từ những thói quen nhỏ được lặp đi lặp lại mỗi ngày.

Hãy bắt đầu với 7 thói quen:

1. Đặt tên rõ ràng.
2. Viết hàm ngắn.
3. Tránh lặp lại code.
4. Xóa code không sử dụng.
5. Format code trước khi commit.
6. Review lại code trước khi push.
7. Luôn nghĩ đến người đọc code tiếp theo.

Nếu duy trì những thói quen này trong vài tháng, bạn sẽ nhận thấy mã nguồn của mình dễ đọc hơn, dễ bảo trì hơn và chuyên nghiệp hơn rất nhiều. Đây cũng là một trong những yếu tố giúp lập trình viên phát triển từ Junior lên Mid-level và Senior trong môi trường làm việc thực tế.