Complete Guide to Resolving Git Pull Conflicts Using Remote Changes

Problem Background of Git Pull Conflicts

In distributed version control systems, Git stands out as one of the most popular tools. When multiple developers collaborate, pulling the latest code from a remote repository is a common task. However, if conflicts exist between the local and remote branches during a pull operation, Git prevents automatic merging and requires manual conflict resolution. This can be an obstacle for users who want to quickly synchronize with remote code.

Core Solution: Forcefully Overwriting Local Changes

When you are certain about discarding all local changes and adopting the remote version, the most straightforward approach is using the git reset --hard command. This method does not perform an actual merge but directly resets the local branch pointer to match the remote branch.

Basic Operation Steps

# Fetch the latest information from the default remote origin
git fetch

# Hard reset the current branch (e.g., master) to origin/master
git reset --hard origin/master

This two-step operation first retrieves the latest state from the remote repository, then completely resets the local branch to match the remote branch. The hard reset (--hard) option discards all uncommitted local changes, including modifications in the working directory and staging area.

Best Practices for Safe Operations

Since hard reset is an irreversible operation, it is strongly recommended to create a backup branch before execution. This ensures that you can restore the previous code state if the operation proves to be a mistake.

# Create a backup branch at the current HEAD position
git branch backup-branch

# Then perform the reset operation
git fetch
git reset --hard origin/master

Alternative Approach: Preserving Commit History

If you wish to retain local commit history while making the final result appear as if only the remote version was kept, you can use a merge strategy approach. This method creates a merge commit but specifies using the remote version's content.

# Fetch remote updates
git fetch

# Create a backup of the current master branch
git branch old-master

# Reset to remote master
git reset --hard origin/master

# Merge the old branch using the ours strategy
git merge -s ours old-master

The -s ours merge strategy here instructs Git to always use the current branch's version (i.e., the reset origin/master) during merging, ignoring any changes from old-master.

Other Conflict Resolution Strategies

In addition to the above methods, you can use the theirs option with the recursive merge strategy:

git pull -s recursive -X theirs

This approach automatically selects the remote version to resolve conflicts during a genuine merge but may retain local changes that do not conflict.

Method Comparison and Selection Guide

Different methods suit different scenarios:

• git reset --hard: Completely discards local changes, simplest and most direct
• Merge strategy approach: Preserves commit history, suitable for projects requiring audit trails
• recursive -X theirs: Partially retains non-conflicting local changes, more conservative

Conclusion and Recommendations

When dealing with Git pull conflicts, choosing the appropriate method depends on your specific needs. If you are certain about fully adopting the remote version, git reset --hard is the most effective solution. Regardless of the method chosen, it is advisable to create backups before execution to prevent accidental data loss. Understanding how these tools work helps manage code versions more efficiently in team collaborations.