Advanced merging strategies

Advanced Merging Strategies

Git's merge operations are an indispensable part of version control, but a simple git merge may not meet the needs of complex scenarios. Advanced merging strategies can address issues such as branch differences, conflict resolution, and history optimization.

Recursive Merge

The recursive merge is Git's default three-way merge strategy, suitable for most branch merging scenarios. When multiple common ancestors exist, Git automatically creates a virtual merge base:

# Create and switch to a branch
git checkout -b feature/login
# Modify files and commit
git commit -am "Add login feature"
# Switch back to the main branch
git checkout main
# Perform a recursive merge
git merge feature/login

The recursive merge will:

1. Find the nearest common ancestor of the two branches
2. Create a merge commit incorporating changes from all three versions
3. Automatically resolve compatible modifications

When conflicts occur, Git pauses the merge process and marks conflict areas in the files:

// Conflict marker example
<<<<<<< HEAD
const apiVersion = 'v2';
=======
const apiVersion = 'v3-beta';
>>>>>>> feature/login

Squash Merge

The squash merge compresses multiple commits into a single commit, ideal for tidying up feature branch history:

git merge --squash feature/payment
git commit -m "Integrate payment feature"

Advantages:

• Maintains a linear and clean main branch history
• Avoids polluting the main branch with intermediate commits from feature branches
• Facilitates rolling back entire features

Typical use case:

# Long-running feature branch
git checkout -b feature/checkout
# After 20 commits...
git checkout main
git merge --squash feature/checkout

Fast-Forward Merge

When the target branch is a direct ancestor of the current branch, Git performs a fast-forward merge by default:

git checkout feature/search
# Modify files and commit
git commit -am "Optimize search algorithm"
git checkout main
git merge feature/search  # Automatically fast-forwards

Force-disable fast-forward merge:

git merge --no-ff feature/search

Differences between fast-forward and non-fast-forward merges:

• Fast-forward merges do not create merge commits
• Non-fast-forward merges always generate merge nodes
• History appears as either straight lines or forked graphs

Ours Merge

A special merge strategy that completely adopts the current branch's version, ignoring changes from other branches:

git merge -s ours feature/legacy

Usage scenarios:

1. Declare that a branch has been merged (while actually ignoring its changes)
2. Resolve conflicts caused by file permission changes
3. Mark merge points for specific branches without introducing code

Subtree Merge

Merges a project as a subdirectory into another project, suitable for managing dependencies:

git remote add libgit https://github.com/libgit/libgit
git fetch libgit
git merge -s subtree --allow-unrelated-histories libgit/main

Subtree merge configuration steps:

1. Add a remote repository reference
2. Create a subtree merge strategy
3. Specify the merge prefix directory

# Specify merge into a subdirectory
git merge -s subtree --prefix=lib/ libgit/main

Rename Detection Strategy

Git automatically detects file renames during merges, with adjustable sensitivity:

git merge -X rename-threshold=50% feature/refactor

Threshold recommendations:

• Default 50% works for most cases
• Complex refactoring may require lowering to 30%
• Precise matching can increase to 70%

Merge Driver Configuration

Custom merge strategies for specific file types:

# .gitattributes configuration example
*.json merge=union
*.lock merge=ours
*.min.js merge=binary

Common merge drivers:

• text: Standard text merging
• binary: Disables merging
• union: Preserves changes from both sides
• ours: Prioritizes the current branch's version

Complex Conflict Resolution

Multi-file conflict resolution workflow:

1. Identify conflicted file status:

git status --porcelain | grep "^UU"

2. Use graphical tools:

git mergetool -t vscode

3. Manual resolution example:

// Before resolution
<<<<<<< HEAD
function fetchData() {
=======
async function getData() {
>>>>>>> feature/async

// After resolution
async function fetchData() {

4. Mark conflicts as resolved:

git add src/api.js
git merge --continue

Merge Testing Strategy

Best practices for ensuring merge safety:

Pre-merge check script:

#!/bin/sh
git merge --no-commit --no-ff $1
npm run test
if [ $? -ne 0 ]; then
    git merge --abort
    exit 1
fi
git commit

CI pipeline integration:

# .gitlab-ci.yml example
merge_validation:
  script:
    - git merge origin/$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME --no-ff --no-commit
    - npm run build
    - npm run test
  allow_failure: false

History Optimization

Standard format for merge commit messages:

feat(payment): Integrate Alipay interface

* Add Alipay SDK dependency
* Implement payment flow controller
* Update documentation

Refs: #123, #456

Multi-branch merge strategy:

# Merge three feature branches
git merge --no-ff feature/a feature/b feature/c

Interactive history reorganization:

git rebase -i main --autosquash