10 Git Techniques You Need to Know Before You Join a Team

Prepare to join the teamwork Git journey? This article will explain the necessary Git skills in team collaboration step by step to help you get started easily.

Core points:

• Master the basics of Git: create, clone repositories, commit changes, and push and pull remote repositories.
• Proficient in using branching and merging: allows multiple developers to process different parts of projects at the same time without interfering with each other.
• Solve merge conflicts: Ensure smooth merge of branches.
• Learn to use Git LFS to handle large binary files: avoid repository sizes expand infinitely with each commit.

1. Clone: ​​The starting point of teamwork

Unlike individual projects starting from scratch, team collaboration usually requires cloning an existing code base to the local system first. This allows you to work on your own copy and avoid conflicts with others' changes.

Clone command:

git clone /path/to/repo
git clone username@remote_system_ip:/path/to/repo/on/remote
git clone https://github.com/sdaityari/my_git_project.git

When cloning, you can choose multiple protocols to connect to the source.

2. Manage remote warehouses

After cloning, the repository will retain a pointer to the source code, i.e., the remote repository. A remote repository is another copy pointing to the same repository. When cloning, a remote pointer named origin will be automatically created to point to the source.

View remote repository:

git remote -v

Add remote repository:

git remote add remote_name remote_address

Delete remote repository:

git remote remove remote_name

Modify the remote warehouse address:

git remote set-url remote_name new_remote_address

3. Git branch

One of the advantages of Git is its powerful branching capabilities. A branch is a pointer to a commit in the repository, which in turn points to its predecessor commit. Therefore, branches represent a chronological list of commits. Creating a branch is really just creating a new pointer to a commit, but it essentially represents a new, independent development path.

In team collaboration, branches are used to distinguish different work lines. Multiple developers deal with various issues at the same time, ideally, these issues are processed on different branches, ensuring that new code is logically separated before code review and merge.

View branch:

git branch

Create branch:

git branch new_branch
git checkout -b new_branch  # 创建并切换到新分支

Rename branch:

git branch -m new_renamed_branch

Delete branch:

git branch -D new_renamed_branch

4. Update local repository: Merge

After completing the problem processing, you need to merge the branches into the underlying branch.

Merge command:

git checkout base_branch
git merge new_branch

The merge process can be time-consuming because it can lead to conflicts.

5. Handle conflicts

If the base branch also updates the same part of the same file after you create a new branch, Git will try to keep all the data. If it is not possible to automatically decide which changes to be kept, a conflict will be raised.

When there is a conflict, git status will display a list of files modified in both branches. The conflicting file contains the following lines:

<code>...
...
========
...
...
>>>>>>>> new_branch</code>

Developers need to manually edit the file, decide which changes to keep, and then submit the changes.

6. Synchronize changes with remote repository

Before publishing the code to a remote repository, you need to update the local repository to include any changes that have occurred since the last update.

Update remote changes:

git clone /path/to/repo
git clone username@remote_system_ip:/path/to/repo/on/remote
git clone https://github.com/sdaityari/my_git_project.git

git pull Download the data first and merge it with the local branch. Conflicts may also occur when pulling remote changes.

Publish changes to remote repository:

git remote -v

7. Cloud Git: Fork

Cloud collaboration introduces the concept of Fork. Fork is a copy of the cloud central repository under your username. You can push changes to your Fork without affecting the original repository.

This will affect previous steps. You clone your own Fork, so the local repository's origin points to the cloud's Fork. To get updates to the original repository, you need to manually add a remote repository named upstream to point to the original repository.

Merge changes to the original repository via Pull Request.

8. Code review via Pull Request

Pull Request is a request to merge branch code into another branch. It summarizes the differences between the two branches and starts discussions between developers and administrators. Code reviews can lead to more changes and can only be merged if the administrator is satisfied.

9. Understand Git workflow

Personal projects may use only one branch (centralized workflow). More complex is the feature branch workflow, with each feature or bug fix corresponding to one branch.

Gitflow workflow contains development, features, releases, and hot fix branches.

10. Processing large files: Git LFS

Git is difficult to handle binary and executable files. Git LFS solves this problem by storing large binary files in the cloud and replacing them with text pointers.

Further reading

This article introduces the Git tips you may use when joining a team. For more content, please refer to:

• Jump Start Git
• Professional Git

FAQ

This article has included answers to frequently asked questions.

The above is the detailed content of 10 Git Techniques You Need to Know Before You Join a Team. For more information, please follow other related articles on the PHP Chinese website!