Complete Guide to Retrieving Modified Files in Git Branches

Core Principles of File Change Detection in Git Branches

In software development, accurately identifying file changes in Git branches is crucial for code review, merge conflict resolution, and continuous integration. Git provides several powerful commands to meet this need, with the git diff command series being the most direct and effective tool.

File Change Detection Based on Merge Base

The most reliable approach is using the command git diff --name-only <notMainDev> $(git merge-base <notMainDev> <mainDev>). This method avoids context changes caused by branch switching by directly comparing the target branch with the most recent common ancestor of both branches. The merge base represents the last common commit before the branches diverged, and by comparing this base with the target branch, you can precisely obtain file changes that occurred only on the target branch.

The execution flow of this command is as follows: first, git merge-base calculates the most recent common commit of branches <notMainDev> and <mainDev>; then, git diff compares this common commit with the <notMainDev> branch; the --name-only option ensures that only the names of changed files are output, without displaying specific diff content.

Comparative Analysis of Alternative Approaches

Another common method is to first switch to the target branch and then execute git diff --name-only <mainDev>. While this approach is simple and intuitive, it requires switching branch contexts, which may introduce unnecessary complexity in automation scripts. In comparison, the merge base-based approach is more stable and reliable.

Git also provides a shorthand syntax git diff main...branch, which is essentially a shortcut for git diff $(git merge-base main branch) branch. This syntax is more concise but may require using backticks instead of the $() syntax in certain shell environments.

Practical Applications in CI/CD Environments

In continuous integration pipelines, obtaining a list of changed files is crucial for optimizing build processes. Referring to GitLab CI/CD practices, you can use git diff-tree --no-commit-id --name-only -r <commit hash> to retrieve file changes introduced by specific commits. This method is particularly suitable for scenarios where code checks or tests need to be executed only on changed files.

In the context of merge requests, you can combine environment variables for comparison: git diff-tree --name-only --no-commit-id $CI_MERGE_REQUEST_TARGET_BRANCH_SHA. It's important to note that this method requires the pipeline to run on merge request events and ensures that Git is available in the runtime environment.

Code Examples and Best Practices

Here is a complete example demonstrating how to safely retrieve branch change files in a shell script:

#!/bin/bash
# Define branch names
FEATURE_BRANCH="feature/new-ui"
MAIN_BRANCH="main"

# Get merge base and compare file changes
MERGE_BASE=$(git merge-base $FEATURE_BRANCH $MAIN_BRANCH)
CHANGED_FILES=$(git diff --name-only $MERGE_BASE $FEATURE_BRANCH)

# Process changed files
echo "Changed files list:"
echo "$CHANGED_FILES"

# Perform specific operations on each changed file
for file in $CHANGED_FILES; do
    if [[ "$file" == *.js ]]; then
        echo "Executing JavaScript file check: $file"
        # Add specific check commands here
    fi
done

In practical applications, it's recommended to add error handling logic to ensure branches exist and commands execute successfully. Additionally, consider using origin/main instead of the local main branch to avoid comparison inaccuracies caused by outdated local branches.

Summary and Recommendations

The choice of appropriate method depends on the specific use case. For daily development, the merge base-based git diff command provides the best accuracy and reliability. In CI/CD environments, combining platform-specific environment variables can build more intelligent build processes. Regardless of the chosen method, understanding Git's version comparison mechanism is key to achieving efficient file change management.