Git supports many kinds of workflows. The one we usually use is this. Create a main branch remotely and create functional branches locally. The daily workflow is as follows:

Go to your own working branch
$ git checkout work

Work
....

Submit changes to the working branch
$ git commit -a

Back to the main branch
$ git checkout master

Get the latest remote modifications, no conflicts will occur at this time
$ git pull

Back to the working branch
$ git checkout work

Use rebase to merge the modifications to the main trunk. If there are conflicts, resolve them at this time
$ git rebase master

Back to the main branch
$ git checkout master

Merge the modifications of the working branch without conflicts at this time.
$ git merge work

Commit to remote trunk
$ git push

The advantage of this is that the history on the remote trunk is always linear. Everyone resolves conflicts on their local branch and does not create conflicts on the trunk.

The answer given by the friend above is very good. I will add one more information here for the poster’s reference. This was written by Brother Ruan, [git branch management strategy](http://www.ruanyifeng.com/blog/2012/0...).

You can develop together on a branch. When you make changes, use

git stash

In this way, all local modifications are cached in a stack, and then other people’s modifications are synchronized

git pull --rebase

The next step is to restore your changes to the latest node

git stash pop

Then use git commit to submit, so that the version of a branch will continue to develop in order, rather than like knitting a sweater. You can take a look at the comparison chart before and after we use this method

Before:

After