Tại sao Git Rebase có thể thay đổi hoàn toàn cách bạn làm việc với Git

Tại sao Git Rebase có thể thay đổi hoàn toàn cách bạn làm việc với Git

Khi làm việc với Git, việc quản lý lịch sử commit (commit history) quan trọng không kém gì việc viết code sạch sẽ. Một trong những công cụ mạnh mẽ nhất – và đôi khi bị hiểu nhầm nhất – để thực hiện việc này chính là git rebase.

Git Rebase là gì?

Về cơ bản, git rebase được sử dụng để di chuyển hoặc "phát lại" (replay) các commit từ nhánh này sang nhánh khác.

Thay vì hòa nhập các nhánh lại với nhau (như git merge), rebase sẽ viết lại lịch sử commit để làm cho công việc của bạn trông giống như nó được xây dựng dựa trên một nhánh khác ngay từ đầu.

Ý tưởng cốt lõi

Hãy giả sử bạn có cấu trúc nhánh như sau:

main:     A --- B --- C
feature:             D --- E

Bây giờ, có các commit mới được thêm vào main:

main:     A --- B --- C --- F --- G
feature:             D --- E

Nếu bạn chạy lệnh:

git rebase main

Git sẽ thực hiện các bước sau:

1. Tạm thời loại bỏ các commit D và E.
2. Di chuyển nhánh của bạn đến G.
3. Phát lại (replay) D và E lên trên G.

Kết quả thu được:

main:     A --- B --- C --- F --- G
feature:                         D' --- E'

Lưu ý: D' và E' là các commit mới (phiên bản đã được viết lại).

Tại sao nên sử dụng Rebase?

1. Lịch sử commit sạch sẽ

Rebase tạo ra một lịch sử commit tuyến tính, giúp việc đọc và hiểu luồng phát triển dễ dàng hơn nhiều.

Thay vì có cấu trúc rối rắm như sau:

      /--- D --- E
A --- B --- C --- M

Bạn sẽ có một dòng thẳng tắp:

A --- B --- C --- D --- E

2. Tốt hơn cho việc Review code (Code Review)

Việc review một lịch sử tuyến tính, gọn gàng dễ dàng hơn nhiều so với việc phải xử lý các commit merge phức tạp.

3. Tránh các commit Merge không cần thiết

Rebase giúp ngăn chặn sự lộn xộn do các thông báo merge tạo ra, ví dụ:

Merge branch 'main' into feature

So sánh Rebase và Merge

Tính năng	git merge	git rebase
Lịch sử	Phi tuyến tính (có phân nhánh)	Tuyến tính (thẳng hàng)
Commit mới	Thêm commit merge	Viết lại commit
An toàn	An toàn (không viết lại lịch sử)	Rủi ro nếu sử dụng sai
Hợp tác	Được ưu tiên	Cần sự cẩn trọng

Các lệnh cơ bản

Rebase nhánh hiện tại lên một nhánh khác

git rebase main

Rebase tương tác (Interactive Rebase)

git rebase -i HEAD~3

Lệnh này cho phép bạn:

• Chỉnh sửa commit (Edit)
• Gộp commit (Squash)
• Sắp xếp lại thứ tự commit (Reorder)
• Xóa commit (Remove)

Ví dụ:

pick 123abc Thêm tính năng đăng nhập
pick 456def Sửa lỗi chính tả
pick 789ghi Cải thiện giao diện

Bạn có thể đổi thành:

pick 123abc Thêm tính năng đăng nhập
squash 456def Sửa lỗi chính tả
pick 789ghi Cải thiện giao diện

Điều gì xảy ra bên trong?

Khi bạn chạy rebase:

1. Git tìm thấy tổ tiên chung (common ancestor).
2. Trích xuất các commit của bạn dưới dạng các bản vá (patches).
3. Đặt lại con trỏ nhánh của bạn (reset).
4. Áp dụng các bản vá này một cách tuần tự.

Đó là lý do tại sao mã băm (hash) của commit thay đổi – vì chúng thực chất là các commit mới.

Xử lý xung đột (Conflicts)

Trong quá trình rebase, xung đột có thể xảy ra. Git sẽ tạm dừng và hiển thị:

CONFLICT (content): Merge conflict in file.c

Các bước để giải quyết:

1. Sửa xung đột thủ công.
2. Add file đã sửa:

   git add file.c

3. Tiếp tục quá trình rebase:

   git rebase --continue

Nếu cần hủy bỏ:

git rebase --abort

Quy tắc vàng của Rebase

❗ Tuyệt đối không rebase các nhánh công cộng/chia sẻ (public/shared branches)

Tại sao?

Vì rebase viết lại lịch sử, và điều này có thể làm hỏng công việc của các nhà phát triển khác.

Khi nào bạn nên dùng Rebase?

Nên dùng rebase khi:

• Làm việc trên các nhánh tính năng cục bộ (local feature branches).
• Dọn dẹp commit trước khi đẩy code (push).
• Muốn giữ lịch sử tuyến tính, gọn gàng.

Tránh rebase khi:

• Làm việc trên các nhánh chia sẻ (shared branches).
• Nhánh đã được push và đang được người khác sử dụng.

Ví dụ nâng cao: Gộp commit (Squashing)

Trước khi squash:

Thêm tính năng
Sửa lỗi chính tả
Sửa bug
Cải thiện code

Sau khi squash:

Thêm tính năng (phiên bản sạch)

Lệnh thực hiện:

git rebase -i HEAD~4

Những sai lầm thường gặp

1. Rebase nhánh chia sẻ

Điều này có thể gây ra sự nhầm lẫn lớn và làm hỏng lịch sử của dự án.

2. Quên Force Push

Sau khi rebase, bạn phải đẩy code bằng lệnh force:

git push --force

(hoặc an toàn hơn:)

git push --force-with-lease

3. Mất commit

Nếu có sự cố xảy ra, bạn có thể dùng lệnh sau để khôi phục:

git reflog

Bạn có thể khôi phục lại các commit đã bị mất.

Mô hình tư duy

Hãy tưởng tượng rebase như việc:

"Lấy các thay đổi của tôi và giả vờ như tôi đã viết chúng sau phiên bản mới nhất của nhánh đó."

Kết luận

Git Rebase là một công cụ mạnh mẽ giúp:

• Giữ lịch sử sạch sẽ.
• Cải thiện sự hợp tác (khi dùng đúng cách).
• Giúp duy trì cấu trúc commit chuyên nghiệp.

Tuy nhiên, nó phải được sử dụng với kỷ luật và sự hiểu biết.

Nếu bạn làm chủ được rebase, bạn sẽ chuyển từ việc chỉ "sử dụng Git" sang thực sự kiểm soát lịch sử dự án của mình.

Lời khuyên cuối cùng

Hãy bắt đầu sử dụng rebase trong quy trình làm việc cục bộ (local) của bạn trước, sau đó dần dần áp dụng vào các quy trình nhóm với các hướng dẫn rõ ràng.

Chúc bạn viết code vui vẻ 🚀