git pull command: --force, --rebase option, fetch difference, conflict resolve

This article covers the most common questions about the git pull command. We'll cover the basic concepts and usage, the --force option, the --rebase option, and how to resolve conflicts.

1. Understanding git pull

The git pull command applies changes from a remote repository to your local repository. This is done in two steps. The git pull command uses the git fetch command internally to fetch the changes from the remote repository locally and cache them, git merge command to merge those changes into the local repository.

If the commit in the remote repository is just ahead, the pull is easily completed using a fast-forward strategy. However, as the git merge post indicates, conflicts may arise during the merge phase, at which point the developer is given the opportunity to resolve the conflict. Optionally, you can use the rebase strategy instead of merging.

It's easy to use. When you pull changes from a specific branch in a remote repository, you specify the remote name and the branch name.

$ git pull origin main

If you don't write the remote repository name and branch name as shown below, it may have unintended consequences, depending on your current working branch and your settings. Whenever possible, use the remote repository name and branch name together, as shown in the command above.

$ git pull

Now let's see the results of running `git pull' in each situation.

1.1 Fast forward strategy

In git pull, fast-forward strategy means that the remote branch is a few commits ahead of the last commit on the local branch. For example, if the local branch has commit A <- commit B and the remote branch has commit A <- commit B <- commit C, then git pull will only take commit C from the remote branch and append it to the local branch. to the local branch.

In this case, no merge is required, so the merge process is not interrupted, and there is no need to create a separate merge commit. Let's see this in action.

As you can see from the output, we used the fast-forward strategy, and the git pull process was automatically completed.

1.2. When you need to resolve a merge conflict

If there are conflicting lines between the remote and local branches, git pull will pause, especially the merge process. For example, if the remote and local branches have made new commits with different changes.

In this case, only git fetch will be performed and we need to finish the merge phase. We already learned how to resolve the merge conflict in the git merge post, so let's see the result of the execution right away.

You can see from the log that there was a merge conflict during the pull, which we resolved and then committed.

2. Difference from git fetch

As briefly mentioned above, the git pull command includes the git fetch command. The git fetch command fetches and saves all the information from the remote branch that the current branch is tracking. Remote branches usually have a name format of origin/main and can be viewed with the git branch -r command, as we saw in the git branch post.

Use the following command

$ git fetch [remote-name]

The result of the execution is

Looking at the output, you can see that some of the messages shown in the git pull output above are from the fetch command. Since we entered the fetch command, we can also get the history of the remote branch like this

3. --force option

The --force option that can be used with the git pull command is actually an option for the git fetch command. It is used when the history of the remote branch and the local branch do not match, for example due to commit deletions. In such cases git fetch will be refused, but the --force option will force the current remote branch commit history to be overwritten by the local tracking branch.

However, this option does not apply to the merge phase, so even if you force a fetch, if it conflicts with the current branch you will need to manually resolve the merge conflict.

Use the following command

$ git fetch --force [remote-name]

or

$ git pull --force [remote-name] [branch-name]

4. --rebase option

The git pull command works on a merge strategy by default. The --rebase option tells git fetch to perform a git rebase command instead of a merge. The differences between merge and rebase are summarized here.

A pull with rebase attaches the commits from the remote branch to the common ancestor of the remote and local branches, and attaches the commits from the local branch to that last commit. This process changes the commit history, so it should be used with care.

To use it, issue the following command

$ git pull --rebase <remote-name> <branch-name>

5. git pull Other options

5.1. --No-commit option

$ git pull --no-commit

This option is used when you want to check the results of the git pull again or add some manipulations. This option will stop the git pull process just before committing. At this point you can add any new operations you want, and then manually commit to complete the pull command.

5.2. The --ff-only option

$ git pull --ff-only

This option forces the pull to complete only in a fast-forward situation, otherwise the pull will be discarded. With this option you can guarantee that your local branch will not be modified, even accidentally, and that only the remote branch will be fully copied.

5.3. -depth options

git pull --depth [depth-number]

This option, which is also found in many other commands, allows you to pull only the number of commits you want. If you don't need the entire commit history of a remote branch, this can save overhead, disk space, etc.

5.4. --Prune Option

$ git pull --prune

This option is used to clean up local branches that track branches that do not currently exist in the remote repository. If you are confident that the remote repository is the source of truth, you can use this option to keep your local Git environment cleaner.

5.5. --autostash option

$ git pull --autostash

This option will automatically stash, or temporarily save, the changes you are currently making and continue with the pull. The stashed changes will automatically come back after the pull is complete. This can be useful if you need to pull before committing.

6. Final thoughts

The git pull command is one of the most important commands for synchronizing remote and local repositories. One of the easiest ways to troubleshoot when using the git pull command is to always think of a pull as a fetch and a merge or rebase as two separate steps.

For a more detailed explanation of the git merge command, see this post.