Merge conflict Git: cách xử lý và rebase mà không sợ mất code

Merge conflict Git là gì, cách đọc dấu xung đột, giải xung đột bằng merge hoặc rebase, và cách cứu code khi chọn nhầm. Chạy thật trên repo của quán Mộc.

Merge conflict xảy ra khi hai nhánh cùng sửa một chỗ trong một file và Git không biết giữ bên nào. Bạn mở file, đọc phần của hai bên, viết lại bản đúng, chạy kiểm tra rồi báo Git đã xong. Lần đầu thấy <<<<<<< ai cũng hơi hoảng, nên mình thử trên một repo thật nhé.

Vì sao Git dừng lại và hỏi bạn?

Ở bài trước, mình nhập file CSV đơn cũ cho hệ thống của quán Mộc. (Quán Mộc và anh Khoa trong bài là nhân vật minh họa của series này.) Bài đó kết thúc bằng một cảnh rất thường gặp khi làm việc nhóm: hai người cùng sửa một file và Git báo xung đột.

Cảnh cụ thể thế này. Bạn đang làm tính năng phí giao hàng theo khoảng cách, trên nhánh riêng feat/phi-giao-theo-km. Trong lúc đó, anh Khoa gộp vào main một thay đổi khác: nâng ngưỡng miễn phí giao hàng từ 150.000đ lên 200.000đ, và cho giỏ trống thì không tính phí. Cả hai cùng sửa hàm tinhPhiGiao. Khi bạn gộp main vào nhánh của mình, Git có hai phiên bản của cùng mấy dòng code và không có cách nào biết dòng nào mới là ý muốn. Chọn sai là mất tính năng của một trong hai người, nên Git dừng lại và để bạn quyết định.

Để bạn làm theo được, mình viết một script dựng sẵn đúng tình huống đó. Bạn cần Git (từ bản 2.28 trở lên, vì script dùng git init -b và git switch), bash (Git Bash nếu bạn dùng Windows) và Node.js 22.18 trở lên (từ bản đó Node chạy thẳng file .ts). Tạo một thư mục trống và lưu file sau, đặt tên dung-xung-dot.sh:

dung-xung-dot.sh
#!/usr/bin/env bash
# Dựng một repo nhỏ của quán Mộc có sẵn tình huống: hai người cùng sửa hàm tinhPhiGiao.
# Chạy: bash dung-xung-dot.sh   (tạo thư mục moc-xung-dot cạnh file này; xóa thư mục đó rồi chạy lại để làm lại từ đầu)
set -euo pipefail

THU_MUC="moc-xung-dot"
[ -e "$THU_MUC" ] && { echo "Thư mục $THU_MUC đã có, hãy xóa nó rồi chạy lại."; exit 1; }

git init -q -b main "$THU_MUC"
cd "$THU_MUC"
git config user.name "Ban"
git config core.autocrlf false
git config user.email "ban@example.com"
mkdir src

# --- Điểm xuất phát: cả hai cùng thấy phiên bản này -----------------------------------------------
cat > src/phi-giao.ts <<'EOF'
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 150000;

export function tinhPhiGiao(tongTien: number): number {
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
}
EOF
git add . && git commit -q -m "Them ham tinh phi giao hang"

# --- Nhánh của BẠN: tính phí theo khoảng cách (hai commit liên tiếp cùng sửa một hàm) ---------------
git switch -q -c feat/phi-giao-theo-km
cat > src/phi-giao.ts <<'EOF'
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 150000;

export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, km - 3) * 5000;
}
EOF
git commit -q -am "Tinh phi giao theo khoang cach"
cat > src/phi-giao.ts <<'EOF'
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 150000;

export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, Math.ceil(km) - 3) * 5000; // km lẻ tính tròn lên
}
EOF
git commit -q -am "Lam tron km le len"

# --- Trong lúc đó, đồng nghiệp (anh Khoa) đã gộp một thay đổi khác vào main ------------------------------
git switch -q main
git config user.name "Khoa"
git config user.email "khoa@example.com"
cat > src/phi-giao.ts <<'EOF'
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 200000; // khuyến mãi mới: miễn phí từ 200.000đ

export function tinhPhiGiao(tongTien: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
}
EOF
git commit -q -am "Doi nguong mien phi giao len 200k, gio trong khong tinh phi"
git config user.name "Ban"
git config user.email "ban@example.com"

echo "Đã dựng xong trong $(pwd)"
git log --oneline --graph --all

Script làm bốn việc: tạo repo với một commit đầu tiên (hàm tinhPhiGiao nhận một tham số), rồi rẽ ra nhánh của bạn với hai commit (thêm tham số km, rồi làm tròn km lẻ lên), rồi quay về main để "anh Khoa" thêm một commit. Dòng cuối in sơ đồ các commit.

Dựng repo
bash dung-xung-dot.sh
Kết quả (mã băm commit của bạn sẽ khác)
Đã dựng xong trong /đường/dẫn/tới/moc-xung-dot
* 2b19d91 Lam tron km le len
* 4f74ad0 Tinh phi giao theo khoang cach
| * ddd720c Doi nguong mien phi giao len 200k, gio trong khong tinh phi
|/  
* 6d58a15 Them ham tinh phi giao hang

Nhìn sơ đồ: từ commit đầu 6d58a15, lịch sử tách làm hai nhánh. Một nhánh là hai commit của bạn, nhánh kia là commit của anh Khoa trên main. Hai nhánh đã đi xa nhau và cùng chạm vào một file.

Thêm một file nữa để biết kết quả cuối có đúng không. Git chỉ biết chữ, không biết code của bạn có chạy được không, nên mình viết năm phép kiểm cho tinhPhiGiao, đặt trong thư mục moc-xung-dot vừa tạo (file này chưa nằm trong Git, bạn đừng git add nó):

moc-xung-dot/kiem-tra.ts
// Chạy: node kiem-tra.ts  (file này chưa nằm trong Git, đừng git add nó)
import { tinhPhiGiao } from "./src/phi-giao.ts";

const cacCa: [string, number, number, number][] = [
  ["giỏ trống", 0, 2, 0],
  ["120.000đ, 2 km", 120000, 2, 15000],
  ["120.000đ, 5,5 km (làm tròn lên 6 km, vượt 3 km: 3 x 5.000đ)", 120000, 5.5, 30000],
  ["180.000đ, 2 km (ngưỡng miễn phí mới là 200.000đ)", 180000, 2, 15000],
  ["250.000đ, 8 km", 250000, 8, 0],
];
for (const [ten, tien, km, mongDoi] of cacCa) {
  const ra = tinhPhiGiao(tien, km);
  console.log(`${ra === mongDoi ? "ĐÚNG" : "SAI "} ${ten}: ra ${ra}, mong đợi ${mongDoi}`);
}

Mỗi ca có một lý do. Ca "giỏ trống" là thay đổi của anh Khoa, ca "5,5 km" là thay đổi của bạn (làm tròn lên rồi mới trừ 3 km), và ca "180.000đ" kiểm ngưỡng miễn phí mới của anh Khoa: 180.000đ không còn được miễn phí. Bản đúng phải giữ được cả hai thay đổi, nên năm ca này đều phải đạt.

Đọc một xung đột: ba phần và dấu hiệu

Giờ chuyển sang nhánh của bạn và gộp main vào:

Gộp main vào nhánh của bạn
cd moc-xung-dot
git switch feat/phi-giao-theo-km
git merge main
Kết quả
Auto-merging src/phi-giao.ts
CONFLICT (content): Merge conflict in src/phi-giao.ts
Automatic merge failed; fix conflicts and then commit the result.

Có hai điều nên để ý. Git nói Auto-merging trước, tức là nó đã tự gộp được một phần của file, rồi mới CONFLICT. Và nó nói rõ việc tiếp theo: sửa xung đột, rồi commit. Đến đây chưa có gì bị mất, cả hai nhánh vẫn còn nguyên. Xem git status:

git status
On branch feat/phi-giao-theo-km
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
	both modified:   src/phi-giao.ts

no changes added to commit (use "git add" and/or "git commit -a")

Hai dòng đáng đọc: both modified: src/phi-giao.ts cho biết file nào cần xử lý, và git merge --abort là lối thoát. Theo tài liệu của git merge, lệnh này hủy quá trình gộp và cố dựng lại trạng thái trước khi gộp, nên tài liệu khuyên bạn commit hoặc stash thay đổi đang dở trước khi chạy merge. Vì vậy hãy giữ working tree sạch trước mỗi lần gộp. Giờ mở file src/phi-giao.ts:

src/phi-giao.ts (đang xung đột)
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 200000; // khuyến mãi mới: miễn phí từ 200.000đ

<<<<<<< HEAD
export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, Math.ceil(km) - 3) * 5000; // km lẻ tính tròn lên
=======
export function tinhPhiGiao(tongTien: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
>>>>>>> main
}

Đây là cách đọc. Mọi thứ ngoài ba dòng đánh dấu là phần Git đã tự gộp. Dòng MIEN_PHI_TU = 200000 đã là giá trị của anh Khoa, vì bạn chưa từng đụng tới dòng đó. Phần giữa <<<<<<< HEAD và ======= là phiên bản của nhánh bạn đang đứng (HEAD), phần giữa ======= và >>>>>>> main là phiên bản của nhánh bạn đang gộp vào (main). Việc của bạn là biến cả khối từ <<<<<<< đến >>>>>>> thành một đoạn code đúng, và xóa luôn ba dòng đánh dấu.

Nếu hai phiên bản khó so, bạn có thể bảo Git in thêm phiên bản gốc. Chạy git merge --abort để quay lại, rồi gộp lại với git -c merge.conflictStyle=diff3 merge main, và khối xung đột sẽ có thêm một phần ở giữa, đánh dấu bằng |||||||:

Khối xung đột với merge.conflictStyle=diff3
<<<<<<< HEAD
export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, Math.ceil(km) - 3) * 5000; // km lẻ tính tròn lên
||||||| 6d58a15
export function tinhPhiGiao(tongTien: number): number {
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
=======
export function tinhPhiGiao(tongTien: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
>>>>>>> main

Phần ||||||| là bản gốc mà cả hai cùng xuất phát (commit 6d58a15). Có nó, bạn thấy ngay mỗi bên đã đổi gì so với gốc: bên bạn thêm km và bỏ phần ? :, bên anh Khoa thêm dòng giỏ trống. Mình thấy cách này dễ đọc hơn hẳn khi xung đột dài. Mình dùng nó theo từng lệnh ở trên và không đổi cấu hình chung của máy; nếu thích, bạn bật mặc định bằng git config merge.conflictStyle diff3.

Giải xung đột: cách sai trước, rồi cách đúng

Cách làm hấp dẫn nhất lúc mới gặp là xóa ba dòng đánh dấu và giữ cả hai đoạn. Mình thử đúng cách đó (chạy lại git merge main nếu bạn đã abort). Sau khi xóa ba dòng, file thành:

src/phi-giao.ts (sau khi chỉ xóa dòng đánh dấu)
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 200000; // khuyến mãi mới: miễn phí từ 200.000đ

export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, Math.ceil(km) - 3) * 5000; // km lẻ tính tròn lên
export function tinhPhiGiao(tongTien: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
}

Chạy phép kiểm:

Chạy thử
node kiem-tra.ts
Kết quả (dòng cuối của thông báo lỗi)
SyntaxError [ERR_INVALID_TYPESCRIPT_SYNTAX]: 'import', and 'export' cannot be used outside of module code

Node in thêm vài dòng chỉ vị trí lỗi, và nó trỏ vào dòng export function tinhPhiGiao(tongTien: number): number { thứ hai. Hàm thứ nhất bị mất dấu } đóng, vì dấu đóng chung của cả hai bản nằm sau khối xung đột, và hai hàm trùng tên nữa chứ. Lỗi này may mà làm file không chạy nổi, nên bạn biết ngay. Có những trường hợp "giữ cả hai" vẫn chạy được mà logic sai, và khi đó chẳng có gì báo cho bạn. Quy tắc của mình: không bao giờ coi xung đột là việc xóa dấu, mà là việc viết lại một đoạn code đúng từ hai ý định.

Ý định của hai bên khá rõ. Bạn muốn thêm tham số km và tính phí theo khoảng cách, anh Khoa muốn giỏ trống miễn phí. Gộp lại:

src/phi-giao.ts (đã giải xung đột)
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 200000; // khuyến mãi mới: miễn phí từ 200.000đ

export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, Math.ceil(km) - 3) * 5000; // km lẻ tính tròn lên
}
Kiểm tra rồi báo cho Git
node kiem-tra.ts
git add src/phi-giao.ts
git status
Kết quả
ĐÚNG giỏ trống: ra 0, mong đợi 0
ĐÚNG 120.000đ, 2 km: ra 15000, mong đợi 15000
ĐÚNG 120.000đ, 5,5 km (làm tròn lên 6 km, vượt 3 km: 3 x 5.000đ): ra 30000, mong đợi 30000
ĐÚNG 180.000đ, 2 km (ngưỡng miễn phí mới là 200.000đ): ra 15000, mong đợi 15000
ĐÚNG 250.000đ, 8 km: ra 0, mong đợi 0

Năm ĐÚNG, tức là cả hai thay đổi đều còn. Lệnh git add src/phi-giao.ts là cách bạn nói với Git "file này đã xử lý xong". Ở git status bạn sẽ thấy file chuyển từ both modified sang modified (đã sẵn sàng commit). Mình chỉ add đúng file cần, vì git add . sẽ kéo cả kiem-tra.ts vào lịch sử. Rồi hoàn tất:

Hoàn tất merge
git commit --no-edit
git log --oneline --graph --all
Kết quả (mã băm của bạn sẽ khác)
*   7a6db23 Merge branch 'main' into feat/phi-giao-theo-km
|\  
| * 837bcb0 Doi nguong mien phi giao len 200k, gio trong khong tinh phi
* | 1bc6ed5 Lam tron km le len
* | d30b212 Tinh phi giao theo khoang cach
|/  
* 9a12e77 Them ham tinh phi giao hang

Merge giữ nguyên lịch sử của cả hai bên và thêm một commit gộp có hai "cha" (hình thoi ở sơ đồ). Mọi commit cũ vẫn còn đúng mã băm cũ, và đó là lý do merge là lựa chọn an toàn nhất.

Rebase: cùng xung đột, nhưng lịch sử khác

Rebase làm cùng một việc theo cách khác. Thay vì gộp hai nhánh bằng một commit mới, nó nhấc các commit của bạn ra, đặt nhánh của bạn lên đầu mới nhất của main, rồi áp lại từng commit của bạn lên đó. Kết quả là một đường thẳng, như thể bạn bắt đầu làm sau khi anh Khoa xong.

Để thử, xóa thư mục moc-xung-dot và chạy lại bash dung-xung-dot.sh (nhớ chép lại kiem-tra.ts vào thư mục mới). Rồi:

Rebase nhánh của bạn lên main
cd moc-xung-dot
git switch feat/phi-giao-theo-km
git rebase main
Kết quả (mã băm của bạn sẽ khác)
Rebasing (1/2)error: could not apply 4f74ad0... Tinh phi giao theo khoang cach
Auto-merging src/phi-giao.ts
CONFLICT (content): Merge conflict in src/phi-giao.ts
Resolve all conflicts manually, mark them as resolved with
"git add/rm <conflicted_files>", then run "git rebase --continue".
You can instead skip this commit: run "git rebase --skip".
To abort and get back to the state before "git rebase", run "git rebase --abort".
Could not apply 4f74ad0... Tinh phi giao theo khoang cach

Chú ý chữ Rebasing (1/2): Git đang áp từng commit một, và nó dừng ở commit thứ nhất trong hai commit của bạn. Đây là điểm khác lớn với merge. Merge gộp cả nhánh một lần nên bạn xử lý xung đột một lần. Rebase thì mỗi commit của bạn có thể xung đột lần riêng. Nhánh của bạn càng nhiều commit sửa cùng chỗ, bạn càng phải giải nhiều lần.

Ba lệnh được Git nhắc ra cũng là ba lối đi bạn cần nhớ. Theo tài liệu của git rebase, --continue chạy tiếp sau khi bạn giải xong xung đột, --skip bỏ qua commit hiện tại, và --abort hủy việc rebase và đưa HEAD về nhánh ban đầu. Thử --abort ngay để thấy nó vô hại:

Hủy rebase
git rebase --abort
git log --oneline
Kết quả (mã băm của bạn sẽ khác)
2b19d91 Lam tron km le len
4f74ad0 Tinh phi giao theo khoang cach
6d58a15 Them ham tinh phi giao hang

Nhánh về đúng như trước: hai commit của bạn với đúng mã băm cũ (2b19d91, 4f74ad0). Không mất gì. Giờ rebase lại và giải xung đột lần này. Mở file lúc đang rebase, bạn sẽ thấy khối xung đột có chiều ngược với lúc merge:

src/phi-giao.ts (đang xung đột, trong lúc rebase)
<<<<<<< HEAD
export function tinhPhiGiao(tongTien: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  return tongTien >= MIEN_PHI_TU ? 0 : PHI_GIAO;
=======
export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, km - 3) * 5000;
>>>>>>> 4f74ad0 (Tinh phi giao theo khoang cach)
}

Hãy nhìn kỹ: phần HEAD bây giờ là code của anh Khoa (main), còn phần dưới là commit của bạn, kèm cả mã băm và lời nhắn. Lý do là rebase đang dựng lại nhánh của bạn trên nền main, nên "bên hiện tại" (HEAD) là main, và các commit của bạn là thứ được áp lên. Tài liệu git rebase ghi rõ rằng khi rebase, bên được gọi là *ours* là chuỗi commit đã dựng lại cho tới lúc này và hai bên bị đảo vai so với merge. Cái bẫy này mình sẽ cho bạn thấy ở mục sau.

Ở commit này, mình giải xung đột để file có cả hai thay đổi, và thêm đúng các dòng của commit này (lúc này chưa có Math.ceil, vì đó là việc của commit thứ hai):

src/phi-giao.ts (giải xung đột ở commit thứ nhất)
// Phí giao hàng của quán Mộc.
export const PHI_GIAO = 15000;
export const MIEN_PHI_TU = 200000; // khuyến mãi mới: miễn phí từ 200.000đ

export function tinhPhiGiao(tongTien: number, km: number): number {
  if (tongTien <= 0) return 0; // giỏ trống thì không tính phí
  if (tongTien >= MIEN_PHI_TU) return 0;
  return PHI_GIAO + Math.max(0, km - 3) * 5000;
}
Báo xong và chạy tiếp
git add src/phi-giao.ts
git rebase --continue

Nếu Git mở trình soạn thảo để bạn sửa lời nhắn commit, cứ lưu và đóng. Với mình, kết quả là:

Kết quả
[detached HEAD a26e5e6] Tinh phi giao theo khoang cach
 1 file changed, 3 insertions(+), 2 deletions(-)
Rebasing (2/2)Successfully rebased and updated refs/heads/feat/phi-giao-theo-km.

Commit thứ hai ("làm tròn km lẻ lên") tự áp lên mà không xung đột. Mình không giải thích đây là may mắn: commit đó chỉ sửa đúng một dòng mà commit thứ nhất đã đưa vào (dòng return PHI_GIAO + ...), và vì mình giữ dòng đó y hệt khi giải xung đột, Git thấy ngữ cảnh khớp. Nếu lúc giải xung đột mình viết dòng đó khác đi, commit thứ hai cũng sẽ xung đột và mình phải giải thêm một lần nữa. Chạy lại node kiem-tra.ts và bạn được năm ĐÚNG, rồi nhìn lịch sử:

git log --oneline --graph --all
* 8e5af9e Lam tron km le len
* a26e5e6 Tinh phi giao theo khoang cach
* ddd720c Doi nguong mien phi giao len 200k, gio trong khong tinh phi
* 6d58a15 Them ham tinh phi giao hang

Một đường thẳng, không có commit gộp. Nhưng để ý: hai commit của bạn có mã băm mới (a26e5e6, 8e5af9e, trước là 4f74ad0, 2b19d91). Rebase không "dời" commit mà tạo commit mới có nội dung tương đương, nên lịch sử của bạn đã bị viết lại. Hậu quả: nếu nhánh của bạn đã được đẩy lên GitHub và người khác đã lấy về, sau rebase hai lịch sử không còn khớp, và bạn phải đẩy bằng git push --force-with-lease. Theo tài liệu của git push, lệnh này chỉ ghi đè khi nhánh trên máy chủ vẫn đúng như bạn tưởng, nên nó an toàn hơn --force khi lỡ có người đẩy thêm. Tài liệu git rebase cũng cảnh báo rằng rebase một nhánh mà người khác đã dựa vào để làm tiếp là ý tồi.

Vậy chọn cái nào? Theo mình: nhánh của riêng bạn, chưa ai dùng, thì rebase cho lịch sử gọn. Nhánh đã chia sẻ, hoặc bạn thấy chưa chắc, thì merge. Merge xấu hơn một chút ở sơ đồ nhưng không bao giờ viết lại thứ gì. Cả hai đều ổn, miễn là nhóm bạn thống nhất, nhiều nơi quy định luôn trong quy tắc của dự án.

Cái bẫy "chọn một bên": mất code mà Git không báo

Có một lối tắt rất hay gặp, nhất là khi vội. Thay vì sửa tay, bạn gõ git checkout --ours file hoặc git checkout --theirs file để lấy luôn một phiên bản. Mình thử đúng lối tắt đó. Ở trạng thái rebase đang dừng ở commit thứ nhất (xóa và dựng lại repo nếu cần), mình lấy bản --theirs, vì trong đầu mình nghĩ "theirs" là của người khác, tức là anh Khoa:

Lối tắt: lấy cả file một bên rồi chạy tiếp
git checkout --theirs src/phi-giao.ts
git add src/phi-giao.ts
git rebase --continue
node kiem-tra.ts
Kết quả
Updated 1 path from the index
[detached HEAD f28d269] Tinh phi giao theo khoang cach
 1 file changed, 4 insertions(+), 4 deletions(-)
Rebasing (2/2)Successfully rebased and updated refs/heads/feat/phi-giao-theo-km.
SAI  giỏ trống: ra 15000, mong đợi 0
ĐÚNG 120.000đ, 2 km: ra 15000, mong đợi 15000
ĐÚNG 120.000đ, 5,5 km (làm tròn lên 6 km, vượt 3 km: 3 x 5.000đ): ra 30000, mong đợi 30000
SAI  180.000đ, 2 km (ngưỡng miễn phí mới là 200.000đ): ra 0, mong đợi 15000
ĐÚNG 250.000đ, 8 km: ra 0, mong đợi 0

Git không phàn nàn gì, rebase "thành công", nhưng hai phép kiểm sai: cả hai thay đổi của anh Khoa (giỏ trống, ngưỡng 200.000đ) biến mất. Có hai lý do chồng lên nhau. Thứ nhất, khi rebase, --theirs là commit của bạn chứ không phải của anh Khoa; vai bị đảo so với merge. Thứ hai, git checkout --theirs file lấy cả file từ một bên, không chỉ khối đang xung đột, nên dòng MIEN_PHI_TU = 200000 mà Git đã tự gộp đúng cũng bị đè về 150000. Đây là loại lỗi mình sợ nhất vì nó không làm gì đỏ cả; nếu không có file kiem-tra.ts, nó sẽ lọt vào main.

Lỡ làm hỏng rồi thì cứu bằng gì?

May mắn là Git không xóa gì ngay khi rebase. Mọi vị trí mà HEAD từng đứng được ghi lại trong reflog. Theo tài liệu của git reflog, reflog ghi lại mỗi lần đầu nhánh hoặc tham chiếu khác được cập nhật trong repo trên máy bạn; theo mặc định các mục cũ hơn 90 ngày bị dọn, và mục trỏ tới commit không còn nằm trong lịch sử của nhánh (như các commit cũ của bạn sau một lần rebase) bị dọn sớm hơn, sau 30 ngày. Vậy là bạn có khoảng một tháng để hối hận. Chạy:

Xem lịch sử vị trí HEAD
git reflog
Kết quả (mã băm của bạn sẽ khác)
f450fa1 HEAD@{0}: rebase (continue) (finish): returning to refs/heads/feat/phi-giao-theo-km
f450fa1 HEAD@{1}: rebase (continue) (pick): Lam tron km le len
f28d269 HEAD@{2}: rebase (continue): Tinh phi giao theo khoang cach
ddd720c HEAD@{3}: rebase (start): checkout main
2b19d91 HEAD@{4}: rebase (abort): updating HEAD
ddd720c HEAD@{5}: rebase (start): checkout main
2b19d91 HEAD@{6}: checkout: moving from main to feat/phi-giao-theo-km
ddd720c HEAD@{7}: commit: Doi nguong mien phi giao len 200k, gio trong khong tinh phi

Cách đọc: đọc từ dưới lên là theo thời gian. Dòng rebase (start): checkout main (HEAD@{3}) đánh dấu lúc bạn bắt đầu rebase hỏng, và dòng ngay dưới nó (HEAD@{4}, mã 2b19d91) là nơi nhánh của bạn đứng trước đó, tức là commit "Lam tron km le len" ban đầu. (Ở đây có thêm một cặp rebase (abort) vì mình đã thử --abort ở mục trước; nếu bạn bỏ qua bước đó, dòng của bạn sẽ ở vị trí khác, nên hãy đọc theo chữ rebase (start) chứ đừng đếm theo số.) Đưa nhánh về đó:

Quay về trước khi rebase hỏng
git reset --hard HEAD@{4}
git log --oneline
Kết quả
HEAD is now at 2b19d91 Lam tron km le len
2b19d91 Lam tron km le len
4f74ad0 Tinh phi giao theo khoang cach
6d58a15 Them ham tinh phi giao hang

Nhánh về đúng lúc trước khi rebase, hai commit cũ còn nguyên. Giờ rebase lại, và lần này giải xung đột bằng tay như ở mục trước (viết file có cả hai thay đổi, git add, git rebase --continue). Chạy node kiem-tra.ts thì năm ĐÚNG. Cẩn thận với git reset --hard: nó vứt mọi thay đổi chưa commit trong working tree, nên chỉ dùng khi bạn chắc những gì chưa commit không còn cần.

Làm gì để ít xung đột ngay từ đầu

Không ai tránh hết xung đột, nhưng vài thói quen làm nó nhỏ và ít đi. Mình giữ nhánh ngắn: một nhánh chỉ làm một việc và sống một hai ngày, vì nhánh sống càng lâu thì main càng đi xa và khối xung đột càng lớn. Mình cũng kéo main về nhánh của mình thường xuyên (merge hoặc rebase mỗi sáng), vì giải một xung đột nhỏ mỗi ngày dễ hơn giải một đống vào ngày cuối. Mình không định dạng lại cả file (tab thành dấu cách, đổi chỗ các hàm) cùng lúc với việc sửa logic, vì thay đổi dạng đó làm gần như mọi dòng thành "đã sửa" và gây xung đột ở những chỗ không ai thật sự sửa logic. Và quan trọng hơn cả, mình luôn có một phép kiểm chạy được như kiem-tra.ts: không có nó, "giải xong" chỉ nghĩa là "hết dấu <<<<<<<".

Để các bước trong bài không âm thầm sai, mình viết bảy test cho demo, mỗi test dựng một repo mới trong thư mục tạm và kiểm lại một bước: repo có đúng hình dạng, merge xung đột đúng chỗ, xóa dấu thì code hỏng, giải tay thì ra năm ĐÚNG và commit gộp có hai cha, ours/theirs đảo vai khi rebase, chọn cả file theirs làm hai phép kiểm sai, và --abort cùng reflog đưa nhánh về như cũ. Test chạy bằng node --test xung-dot.test.ts (file test nằm trong repo demo, bài này mình không dán). Mọi thao tác ở trên chạy trên Git 2.32 của máy mình, nên output của bạn có thể khác chữ ở vài dòng nếu dùng bản Git mới hơn.

Code đã gộp xong, nhưng máy đồng nghiệp lại không chạy được

Đến đây nhánh của bạn đã nằm trên main đúng và có phép kiểm đi kèm. Nhưng đời không dừng ở đó: anh Khoa kéo main về, chạy thử và nhắn lại rằng máy anh báo lỗi trong khi máy bạn thì chạy ngon. Câu "máy em chạy mà" là một trong những câu quen thuộc nhất của nghề này, và nguyên nhân thường nằm ở cấu hình và biến môi trường chứ không nằm trong code. Giải quyết nó là việc của các bài viết sau.

Bạn theo dõi cả hành trình ở Nhận dự án cũ: từ bug report đến pull request. Bài Git branch và pull request nói về luồng làm việc mà xung đột này nằm trong, và các câu hỏi về Git, như merge khác rebase ở chỗ nào, nằm trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.