Resolving Git Merge Conflicts: Using --ours and --theirs Options to Keep File Versions

Introduction

In software development version control, Git merge conflicts are common issues, especially when multiple developers modify the same files. Conflicts may arise from simple changes, such as end-of-line (EOL) differences or accidental modifications. In such cases, users may want to directly keep an entire version of a file without comparing differences individually. This paper provides a command-line approach to quickly resolve merge conflicts by "keeping local" or "keeping remote" versions.

Core Method: Using git checkout --ours and git checkout --theirs

Git offers the --ours and --theirs options, allowing users to choose which version of a file to retain during merge conflicts. --ours refers to the local version of the current branch, while --theirs refers to the remote branch version being merged. This method is particularly useful when the entire file content is deemed valid or invalid, such as handling EOL changes or discarding erroneous modifications in bulk.

After a merge conflict occurs, use the following commands:

git checkout --theirs /path/to/file

This replaces the conflicted file with the remote version, keeping remote changes.

git checkout --ours /path/to/file

This replaces the conflicted file with the local version, keeping local changes.

Afterwards, run git add /path/to/file to mark the file as resolved and continue the merge process.

Code Examples and Analysis

Consider a practical scenario: during a merge, a file conflicts due to EOL changes in a Windows environment. The user wants to keep their local version. The steps are: first, check the conflict status using git status to confirm the conflicted file. Then, execute git checkout --ours conflict_file.txt to retain the local version. Finally, run git add conflict_file.txt and git commit to complete the merge.

Conversely, if the user realizes their modifications are incorrect and needs to accept the remote version, use git checkout --theirs conflict_file.txt. This method avoids opening diff tools, improving efficiency.

Additional Methods: Using git merge --strategy-option

Beyond git checkout, other commands can handle conflicts in bulk. For example, during a merge, use git merge --strategy-option theirs or git merge --strategy-option ours, or during a pull, use git pull -Xtheirs and git pull -Xours. These methods automatically select versions throughout the merge process, suitable for scenarios where all conflicts need to be resolved at once. However, they may not offer as precise control over individual files as the git checkout commands.

Considerations and Best Practices

It is important to note that the meanings of --ours and --theirs differ between merge and rebase scenarios. In a merge, --ours refers to the current branch and --theirs to the branch being merged; in a rebase, --theirs refers to the target branch, which can be confusing. Therefore, it is recommended to verify the Git status before operation.

To ensure code quality, consider backing up important files or using version control history before applying these commands. Additionally, combining with git diff or git log to review changes can aid in making informed decisions.

Conclusion

By using git checkout --ours and git checkout --theirs, developers can quickly retain desired file versions during Git merge conflicts, especially for handling bulk changes or simple conflicts. This approach simplifies workflows and reduces manual intervention. In complex scenarios, other strategy options can be integrated for optimization. Overall, understanding the principles and applications of these commands will enhance version control efficiency.