🛣️ Lộ Trình Học Git Từ A-Z

 Giai đoạn 1: Làm quen với Git

 Mục tiêu: Hiểu Git là gì, tại sao nên dùng

• Git là gì? So sánh với SVN, Dropbox,...
   

• Git hoạt động như thế nào (snapshot vs. version history)
   

• Cài đặt Git trên Windows/Mac/Linux
   

Thiết lập Git lần đầu:

git config --global user.name "Tên bạn"

git config --global user.email "email@example.com"

Giai đoạn 2: Các lệnh Git cơ bản

Mục tiêu: Quản lý dự án cá nhân

• git init – tạo repo mới
   

• git clone – sao chép repo
   

• git status – xem trạng thái
   

• git add – thêm file vào staging
   

• git commit – lưu thay đổi
   

• git log – xem lịch sử commit
   

• git diff – so sánh thay đổi
   

• git reset – quay lại trạng thái trước
   

Mini project gợi ý: Tạo 1 project đơn giản, quản lý bằng Git

Giai đoạn 3: Làm việc với GitHub / GitLab

 Mục tiêu: Làm việc nhóm

• Tạo repo trên GitHub

Push code lên GitHub:

git remote add origin <url>

git push -u origin main

• Pull code mới nhất: git pull
   

• Fork, star, tạo Pull Request (PR)
   

Tip: Học cách viết commit message chuẩn (ngắn gọn, rõ ràng)

Giai đoạn 4: Nhánh (Branch) và Merge

Mục tiêu: Phát triển song song

• git branch – tạo và quản lý nhánh
   

• git checkout -b <branch> – tạo và chuyển nhánh
   

• git merge <branch> – gộp nhánh
   

• Xung đột merge (conflict) và cách giải quyết
   

Giai đoạn 5: Git nâng cao

 Mục tiêu: Làm chủ Git

• git stash – lưu tạm thay đổi
   

• git rebase – tái cấu trúc lịch sử commit
   

• git cherry-pick – chọn 1 commit áp dụng vào nhánh khác
   

• git revert vs. git reset
   

• .gitignore – bỏ qua file
   

• git tag – đánh dấu phiên bản release
   

• Git hooks – tự động hóa hành động (vd: kiểm tra code trước khi commit)

Giai đoạn 6: Làm việc nhóm nâng cao

Mục tiêu: Thực chiến teamwork

• Flow quản lý nhánh:

  • Git Flow
     

  • GitHub Flow
     

  • GitLab Flow
     

• Review code & Pull Request
   

• Conflict nhiều người làm chung 1 file

Tài liệu học Git

• Pro Git Book (Tiếng Việt)
   

• GitHub Docs
   

• Trang luyện tập Git online:
   

  • https://learngitbranching.js.org/
     

  • https://git-school.github.io/visualizing-git/

Mẹo học hiệu quả:

• Dùng CLI (command line) thay vì GUI để nhớ lâu hơn
   

• Làm project thật – không cần to, chỉ cần thực tế
   

• Học xong là viết 1 bài blog/ghi chú lại để củng cố

Đây là một số lệnh cơ bản trong Git mà bạn có thể sử dụng:

1. git init – Tạo một repository (repo) mới trên máy tính của bạn. Dùng để bắt đầu quản lý mã nguồn trong một thư mục.

   git init
   

2. git clone – Sao chép một repository từ một địa chỉ URL, thường dùng để sao chép repo từ GitHub, GitLab, hoặc các dịch vụ Git khác.

   git clone <repository-url>
   

3. git status – Kiểm tra trạng thái của repository hiện tại, bao gồm những thay đổi chưa được commit, file nào đã được thay đổi hoặc thêm vào staging.

   git status
   

4. git add – Thêm file vào staging area (khu vực tạm thời) để chuẩn bị commit. Bạn có thể thêm một file cụ thể hoặc tất cả các thay đổi.

   git add <file-name>   # Thêm một file
   git add .             # Thêm tất cả các file đã thay đổi
   

5. git commit – Lưu các thay đổi đã được thêm vào staging vào lịch sử commit của repository. Bạn cũng có thể thêm thông điệp mô tả commit.

   git commit -m "Thông điệp commit"
   

6. git log – Xem lịch sử các commit trong repository, giúp bạn kiểm tra các thay đổi qua các lần commit.

   git log
   

7. git diff – So sánh sự khác biệt giữa các file trong working directory với staging area hoặc giữa các commit.

   git diff             # So sánh thay đổi trong working directory với staging
   git diff <commit-id> # So sánh giữa các commit
   

8. git reset – Quay lại trạng thái trước, có thể quay lại commit trước hoặc hoàn tác những thay đổi đã thêm vào staging. Có ba loại reset: --soft, --mixed, --hard.

   git reset            # Quay lại commit trước
   git reset --soft <commit-id>  # Quay lại commit và giữ thay đổi trong staging
   git reset --hard <commit-id>  # Quay lại commit và mất tất cả thay đổi
   

Dưới đây là các bước cơ bản khi làm việc với GitHub hoặc GitLab trong một dự án nhóm, từ việc tạo repository cho đến việc sử dụng Pull Request (PR).

1. Tạo repository trên GitHub:

• Đăng nhập vào GitHub.

• Tạo một repository mới bằng cách click vào nút New trên trang chính của GitHub.

• Điền tên cho repository, chọn mức độ công khai (Public hoặc Private), và nhấn Create repository.

2. Push code lên GitHub:

Khi bạn đã có code trong một repository trên máy của mình và muốn đẩy nó lên GitHub:

Bước 1: Thêm remote (nếu chưa có): Để liên kết repository trên máy của bạn với repository trên GitHub, sử dụng lệnh sau:

git remote add origin <url-repository>

Bước 2: Push code lên GitHub: Sau khi đã thêm remote, bạn có thể push code lên repository trên GitHub:

git push -u origin main

Lưu ý: main là tên nhánh chính mặc định trên GitHub. Nếu bạn đang làm việc với một nhánh khác, thay main bằng tên nhánh của bạn.

3. Pull code mới nhất từ GitHub:

Khi làm việc nhóm, bạn cần luôn cập nhật repository với những thay đổi mới nhất từ các thành viên khác:

git pull origin main

Lưu ý: Nếu bạn đang làm việc trên một nhánh khác, thay main bằng tên nhánh đó.

4. Fork và Star một repository:

• Fork: Khi bạn muốn đóng góp vào một dự án mà bạn không phải là chủ sở hữu, bạn có thể "fork" (sao chép) repository của người khác. Để làm điều này, vào trang repository trên GitHub và nhấn vào nút Fork.

• Star: Nếu bạn muốn theo dõi một repository và đánh giá cao nó, bạn có thể nhấn vào nút Star trên trang repository.

5. Tạo Pull Request (PR):

Khi bạn đã thực hiện xong các thay đổi trên nhánh của mình và muốn đưa các thay đổi đó vào nhánh chính (hoặc nhánh khác), bạn cần tạo một Pull Request (PR).

Bước 1: Commit và push các thay đổi lên GitHub (trên nhánh của bạn).

git add .
git commit -m "Mô tả thay đổi"
git push origin <branch-name>

Bước 2: Tạo Pull Request trên GitHub.

• Truy cập trang repository trên GitHub.

• Chọn Pull Requests rồi nhấn New Pull Request.

• Chọn nhánh bạn muốn merge vào nhánh chính (ví dụ: main).

• Thêm mô tả chi tiết về thay đổi của bạn và nhấn Create Pull Request.

Sau khi tạo PR, các thành viên trong nhóm sẽ xem xét và có thể merge PR của bạn vào nhánh chính.

6. Tip: Viết commit message chuẩn:

Commit message giúp mọi người hiểu được những thay đổi bạn đã thực hiện. Một commit message tốt cần phải:

• Ngắn gọn và súc tích: Mô tả những thay đổi trong 50-72 ký tự.

• Chia thành hai phần:

  • Phần đầu là mô tả ngắn gọn.

  • Phần mô tả chi tiết (nếu cần) ở dưới sau một dòng trắng.

Ví dụ commit message chuẩn:

git commit -m "Fix bug in user login validation"

Ví dụ commit message với chi tiết hơn:

git commit -m "Fix bug in user login validation

Fixed issue where users could not log in if their password contained special characters. The login form now correctly escapes special characters."

Giai đoạn 4 trong quy trình phát triển phần mềm sử dụng Git là Quản lý nhánh (Branch) và Merge.

Đây là một phần quan trọng khi bạn làm việc theo nhóm và muốn phát triển song song các tính năng khác nhau mà không làm ảnh hưởng đến mã nguồn chính (main branch).

Dưới đây là các lệnh Git cơ bản liên quan đến nhánh và cách giải quyết xung đột khi merge.

1. Tạo và quản lý nhánh với git branch:

• Lệnh git branch được dùng để quản lý các nhánh trong repository của bạn.

Tạo nhánh mới:

git branch <branch-name>

Lệnh này tạo một nhánh mới có tên <branch-name> nhưng không chuyển sang nhánh đó. Bạn sẽ vẫn ở trên nhánh hiện tại.

Danh sách các nhánh:

git branch

Lệnh này liệt kê tất cả các nhánh trong repository và đánh dấu nhánh hiện tại bằng dấu *.

Xóa nhánh:

git branch -d <branch-name>

Lệnh này xóa nhánh <branch-name>. Nếu bạn chưa merge nhánh đó vào nhánh chính, Git sẽ cảnh báo bạn. Sử dụng -D để buộc xóa mà không kiểm tra tình trạng merge.

2. Tạo và chuyển nhánh với git checkout -b <branch>:

Bạn có thể tạo và chuyển sang một nhánh mới cùng lúc với lệnh git checkout -b <branch-name>:

git checkout -b <branch-name>

Lệnh này sẽ tạo nhánh mới <branch-name> và tự động chuyển sang nhánh đó. Điều này giúp bạn tiết kiệm thời gian thay vì phải chạy hai lệnh riêng biệt.

3. Gộp nhánh với git merge <branch>:

Khi bạn hoàn thành việc phát triển tính năng trên một nhánh con và muốn gộp nó vào nhánh chính (ví dụ: main hoặc develop), bạn sẽ dùng lệnh git merge:

Gộp nhánh vào nhánh hiện tại:

git merge <branch-name>

Lệnh này sẽ gộp các thay đổi từ nhánh <branch-name> vào nhánh bạn đang làm việc hiện tại.

Lưu ý: Trước khi gộp, đảm bảo rằng bạn đã commit hoặc stash mọi thay đổi trên nhánh hiện tại để tránh mất dữ liệu.

4. Xung đột merge (Merge Conflict) và cách giải quyết:

Khi hai nhánh có thay đổi cùng một phần của mã nguồn, Git sẽ không thể tự động gộp chúng và sẽ báo lỗi merge conflict. Bạn cần giải quyết xung đột này bằng tay.

Quy trình giải quyết xung đột:

Bước 1: Kiểm tra xung đột: Khi bạn thực hiện lệnh git merge <branch-name>, Git sẽ thông báo nếu có xung đột. Bạn có thể sử dụng lệnh sau để kiểm tra trạng thái các xung đột:

git status

Các file bị xung đột sẽ được đánh dấu là "unmerged" (chưa hợp nhất).

Bước 2: Mở và giải quyết xung đột trong file: Mở các file có xung đột. Git sẽ đánh dấu các vùng xung đột trong file như sau:

<<<<<<< HEAD
// Code của nhánh hiện tại
=======
// Code của nhánh được merge vào
>>>>>>> <branch-name>

• Phần giữa <<<<<<< HEAD và ======= là code từ nhánh hiện tại.

• Phần giữa ======= và >>>>>>> <branch-name> là code từ nhánh bạn đang gộp vào.

Bạn cần chỉnh sửa các xung đột này bằng cách chọn giữ một phần hoặc kết hợp chúng sao cho hợp lý.

Bước 3: Đánh dấu xung đột đã được giải quyết: Sau khi giải quyết xung đột, bạn cần thêm các file đã sửa vào staging để Git biết rằng xung đột đã được giải quyết:

git add <file-name>

Bước 4: Commit merge: Khi tất cả xung đột đã được giải quyết và các file đã được thêm vào staging, bạn có thể commit các thay đổi:

git commit

Git sẽ tự động tạo một thông điệp commit cho quá trình merge. Bạn có thể sửa thông điệp này nếu cần.

Bước 5: Tiếp tục công việc: Sau khi merge thành công và không còn xung đột, bạn có thể tiếp tục công việc của mình hoặc push các thay đổi lên repository.

Ví dụ về quy trình làm việc với nhánh:

1. Tạo nhánh mới và chuyển sang nhánh đó:

   git checkout -b feature-new-feature
   

2. Thực hiện thay đổi và commit trên nhánh này:

   git add .
   git commit -m "Implement new feature"
   

3. Chuyển sang nhánh chính (main) và gộp nhánh feature vào:

   git checkout main
   git merge feature-new-feature
   

4. Nếu có xung đột, giải quyết xung đột trong các file và commit lại:

   git add .
   git commit
   

5. Push các thay đổi lên GitHub:

   git push origin main
   

Thông qua việc sử dụng nhánh và giải quyết xung đột merge, bạn có thể làm việc hiệu quả khi phát triển song song với các thành viên trong nhóm.

Giai đoạn 5 trong quy trình làm việc với Git là Git nâng cao, nơi bạn có thể làm chủ các công cụ mạnh mẽ của Git để tối ưu hóa quá trình phát triển, quản lý mã nguồn và tự động hóa công việc. Dưới đây là các lệnh và khái niệm nâng cao bạn cần biết:

1. git stash – Lưu tạm thay đổi:

Nếu bạn đang làm việc trên một nhánh và có những thay đổi chưa được commit, nhưng cần chuyển sang làm việc trên một nhánh khác, bạn có thể lưu tạm các thay đổi đó bằng git stash.

Lưu tạm thay đổi:

git stash

Liệt kê các thay đổi đã stash:

git stash list

Khôi phục thay đổi đã stash:

git stash pop  # Khôi phục thay đổi và xóa stash
git stash apply  # Khôi phục thay đổi mà không xóa stash

Xóa stash:

git stash drop stash@{0}  # Xóa một stash cụ thể

2. git rebase – Tái cấu trúc lịch sử commit:

Lệnh git rebase giúp bạn tái cấu trúc lại các commit trong lịch sử của nhánh. Rebase giúp bạn giữ lịch sử commit gọn gàng và dễ đọc hơn, thay vì tạo ra một lịch sử commit với nhiều nhánh phân tán.

Cách dùng cơ bản:

git rebase <branch-name>  # Áp dụng commit từ nhánh này vào nhánh hiện tại

Rebase tương tác (Interactive rebase): Khi bạn cần chỉnh sửa, gộp, hoặc xóa commit trong lịch sử, bạn có thể sử dụng rebase tương tác.

git rebase -i <commit-id>

Lệnh này mở ra một trình soạn thảo cho phép bạn thay đổi các commit, như sửa thông điệp commit hoặc gộp các commit lại với nhau.

3. git cherry-pick – Chọn 1 commit áp dụng vào nhánh khác:

Lệnh git cherry-pick cho phép bạn chọn một commit cụ thể từ một nhánh và áp dụng nó vào nhánh hiện tại mà không cần phải merge toàn bộ nhánh.

Cách dùng:

git cherry-pick <commit-id>

Điều này đặc biệt hữu ích khi bạn chỉ muốn áp dụng một thay đổi nhỏ từ một nhánh mà không muốn kéo toàn bộ các commit khác.

4. git revert vs git reset:

• git revert: Tạo ra một commit mới để hoàn tác thay đổi của một commit trước đó mà không thay đổi lịch sử của repository.

  git revert <commit-id>
  

  • Sử dụng khi bạn muốn hoàn tác thay đổi nhưng không làm mất lịch sử commit.

• git reset: Quay lại một commit trước đó và thay đổi lịch sử của repository, có thể làm mất các thay đổi.

  git reset --hard <commit-id>  # Quay lại commit và xóa các thay đổi
  git reset --soft <commit-id>  # Quay lại commit nhưng giữ các thay đổi trong staging
  

  • Sử dụng khi bạn muốn thay đổi lịch sử commit hoặc xóa hoàn toàn thay đổi.

Tóm lại:

• git revert: Tạo một commit hoàn tác.

• git reset: Thay đổi lịch sử commit.

5. .gitignore – Bỏ qua file:

Khi làm việc với Git, có những file hoặc thư mục bạn không muốn Git theo dõi, chẳng hạn như file cấu hình cá nhân hoặc thư mục build. Bạn có thể thêm những file này vào tệp .gitignore.

Cách tạo .gitignore:

• Tạo file .gitignore trong thư mục gốc của repository.

• Thêm các pattern để chỉ định file hoặc thư mục cần bỏ qua.

Ví dụ .gitignore:

# Bỏ qua các file log
*.log

# Bỏ qua thư mục build
/build/

# Bỏ qua các file nhị phân
*.exe

Sau khi thêm vào .gitignore, Git sẽ không theo dõi những file đó nữa.

6. git tag – Đánh dấu phiên bản release:

Lệnh git tag dùng để đánh dấu các điểm quan trọng trong lịch sử commit, thường là các phiên bản release.

Tạo tag:

git tag v1.0.0  # Tạo tag ở commit hiện tại

Tạo tag với thông điệp:

git tag -a v1.0.0 -m "Release version 1.0.0"

Liệt kê các tag:

git tag

Push tag lên remote repository:

git push origin v1.0.0

Bạn có thể sử dụng tag để đánh dấu các phiên bản chính trong dự án của mình, ví dụ như v1.0.0, v2.1.0, v.v.

7. Git Hooks – Tự động hóa hành động:

Git hooks là các script được chạy tự động khi các sự kiện Git xảy ra, chẳng hạn như trước khi commit hoặc sau khi push. Git hooks rất hữu ích trong việc tự động hóa các tác vụ như kiểm tra mã nguồn trước khi commit.

Ví dụ sử dụng Git hook:

• Mở thư mục .git/hooks trong dự án của bạn.

• Bạn sẽ thấy một loạt các script mẫu, như pre-commit.sample, pre-push.sample.

• Để kiểm tra mã nguồn trước khi commit, bạn có thể sửa đổi file pre-commit:

Cách sử dụng pre-commit hook:

• Mở file .git/hooks/pre-commit và thêm các dòng lệnh để kiểm tra mã trước khi commit (ví dụ, kiểm tra cú pháp).

#!/bin/sh
# Kiểm tra cú pháp trước khi commit
npm run lint

Sau khi chỉnh sửa, đảm bảo rằng script pre-commit có quyền thực thi:

chmod +x .git/hooks/pre-commit

Các loại Git hooks phổ biến:

• pre-commit: Kiểm tra mã nguồn trước khi commit.

• post-commit: Hành động sau khi commit.

• pre-push: Kiểm tra trước khi push lên remote.

• post-merge: Hành động sau khi merge thành công.

Các công cụ và kỹ thuật Git nâng cao này giúp bạn quản lý mã nguồn hiệu quả hơn, tăng tốc quy trình phát triển, và đảm bảo chất lượng mã nguồn trong dự án nhóm. 

Làm việc nhóm nâng cao là giai đoạn quan trọng khi bạn tham gia vào một dự án phát triển phần mềm lớn, nơi bạn cần sử dụng các quy trình quản lý nhánh (branching models) hiệu quả và có hệ thống để làm việc nhóm. Các quy trình như Git Flow, GitHub Flow, và GitLab Flow là những phương pháp giúp tổ chức và quản lý nhánh, đồng thời giúp cải thiện quy trình phát triển phần mềm. Ngoài ra, việc review code và giải quyết xung đột cũng rất quan trọng khi làm việc nhóm.

Dưới đây là các quy trình và khái niệm quan trọng khi làm việc nhóm với Git:

1. Git Flow – Quản lý nhánh với Git Flow:

Git Flow là một quy trình làm việc được phát triển bởi Vincent Driessen. Đây là một mô hình nhánh phổ biến trong các dự án phát triển phần mềm, giúp bạn dễ dàng quản lý các phiên bản và phát triển tính năng song song.

Các nhánh trong Git Flow:

• main: Nhánh chính, chứa mã nguồn đã sẵn sàng cho việc phát hành (production-ready).

• develop: Nhánh phát triển chính, nơi tất cả tính năng mới được gộp vào trước khi phát hành.

• feature/*: Các nhánh phát triển tính năng mới, được tạo từ nhánh develop.

• release/*: Các nhánh phát hành, được tạo khi bạn chuẩn bị phát hành một phiên bản mới.

• hotfix/*: Các nhánh sửa lỗi khẩn cấp, được tạo từ nhánh main để sửa lỗi nhanh chóng trong môi trường sản xuất.

Lợi ích của Git Flow:

• Giúp phân chia công việc rõ ràng và có trật tự.

• Tạo ra một quy trình phát triển dễ dàng kiểm soát các phiên bản và tính năng.

• Phù hợp cho các dự án lớn với nhiều người tham gia.

Cách sử dụng Git Flow:

• Tạo nhánh phát triển tính năng:

  git checkout develop
  git checkout -b feature/your-feature-name
  

• Merge nhánh tính năng vào develop:

  git checkout develop
  git merge feature/your-feature-name
  

• Tạo nhánh phát hành:

  git checkout develop
  git checkout -b release/1.0.0
  

• Tạo nhánh sửa lỗi khẩn cấp:

  git checkout main
  git checkout -b hotfix/1.0.1
  

2. GitHub Flow – Quy trình GitHub Flow:

GitHub Flow là một quy trình làm việc đơn giản và linh hoạt, thường được sử dụng trong các dự án Agile hoặc DevOps. Quy trình này phù hợp với các dự án liên tục cập nhật và có nhịp độ phát triển nhanh.

Các bước trong GitHub Flow:

1. Tạo nhánh mới: Mỗi khi bạn làm việc trên một tính năng hoặc sửa lỗi, bạn tạo một nhánh mới từ main.

   git checkout -b your-feature-branch
   

2. Commit các thay đổi: Thực hiện các thay đổi và commit lên nhánh của bạn.

   git add .
   git commit -m "Add new feature"
   

3. Push nhánh lên GitHub: Push nhánh của bạn lên GitHub để bắt đầu quá trình Pull Request.

   git push origin your-feature-branch
   

4. Tạo Pull Request (PR): Trên GitHub, tạo một Pull Request từ nhánh của bạn vào nhánh main.

5. Review và merge: Sau khi review code, merge PR vào main và deploy (triển khai) ứng dụng.

Lợi ích của GitHub Flow:

• Dễ dàng và nhanh chóng, phù hợp với quy trình phát triển liên tục.

• Tập trung vào việc tạo ra các bản phát hành nhỏ, dễ dàng triển khai và kiểm tra.

• Phù hợp cho các dự án có sự hợp tác chặt chẽ giữa các nhà phát triển và sản phẩm.

3. GitLab Flow – Quy trình GitLab Flow:

GitLab Flow là một quy trình làm việc linh hoạt kết hợp giữa Git Flow và GitHub Flow. Nó được thiết kế để có thể sử dụng cho các dự án có quy mô nhỏ đến lớn và hỗ trợ CI/CD (Continuous Integration/Continuous Deployment).

Các nhánh trong GitLab Flow:

• main: Nhánh chính, chứa phiên bản ổn định của sản phẩm.

• production: Nhánh sản xuất, thường được sử dụng trong môi trường CI/CD để triển khai lên môi trường thực tế.

• feature/*: Nhánh tính năng, được tạo từ nhánh main hoặc production.

• bugfix/*: Nhánh sửa lỗi, tương tự như feature, nhưng dành cho việc sửa lỗi.

• release/*: Nhánh phát hành, dùng để chuẩn bị các tính năng cho phiên bản chính thức.

Cách sử dụng GitLab Flow:

• Tạo nhánh phát triển tính năng từ main hoặc production.

• Tạo Merge Request (MR) từ nhánh tính năng vào main hoặc production.

• Khi MR được thông qua, tiến hành merge và triển khai lên môi trường staging hoặc production.

4. Review Code & Pull Request:

Code Review là một phần quan trọng trong quy trình làm việc nhóm. Khi một người gửi Pull Request (PR) hoặc Merge Request (MR), các thành viên khác trong nhóm sẽ kiểm tra mã nguồn của họ để đảm bảo mã đúng, dễ hiểu và không có lỗi tiềm ẩn.

Các bước trong code review:

1. Đọc mã nguồn cẩn thận: Kiểm tra logic, tính bảo mật và hiệu suất của mã.

2. Đưa ra phản hồi: Chỉ ra các vấn đề cần sửa đổi và đưa ra gợi ý cải thiện.

3. Sửa đổi theo yêu cầu: Thực hiện các sửa đổi cần thiết dựa trên feedback.

4. Merge PR sau khi duyệt: Sau khi PR đã được duyệt, tiến hành merge vào nhánh chính.

5. Xung đột khi nhiều người làm chung 1 file:

Khi nhiều người cùng chỉnh sửa một file hoặc một phần mã, sẽ xảy ra xung đột (merge conflict). Điều này thường xuyên xảy ra khi cả hai cùng sửa cùng một dòng mã.

Cách giải quyết xung đột:

• Thông báo khi có xung đột: Git sẽ thông báo xung đột khi bạn thực hiện merge hoặc rebase.

• Sử dụng các công cụ hỗ trợ: Bạn có thể sử dụng các công cụ như git mergetool để giúp dễ dàng giải quyết xung đột.

• Giải quyết thủ công: Mở file bị xung đột và chọn hoặc chỉnh sửa mã cho phù hợp. Các phần xung đột sẽ được Git đánh dấu rõ ràng trong file.

Lời khuyên:

• Cố gắng commit và push thường xuyên để tránh việc xung đột kéo dài.

• Giao tiếp chặt chẽ với các thành viên trong nhóm để tránh sửa đổi đồng thời cùng một phần mã.

Các quy trình làm việc với Git (Git Flow, GitHub Flow, GitLab Flow) giúp quản lý và điều phối công việc nhóm hiệu quả hơn.

Khi làm việc trong nhóm, bạn cần chú ý đến việc review code, quản lý các nhánh và giải quyết xung đột để duy trì chất lượng và tính ổn định của dự án.