Comprehensive Guide to Extracting Single Files from Other Branches in Git

Introduction

During software development, there is often a need to share or migrate specific files between different branches. Traditional approaches involving branch switching and file copying are not only inefficient but also prone to errors. Git provides multiple elegant solutions for directly extracting single files from other branches. This article systematically introduces these methods and their best practices.

Basic Method: git checkout Command

git checkout is the most classic and widely supported method for cross-branch file extraction. Its basic syntax structure is:

git checkout <source-branch> -- <file-path>

The specific operation process is as follows: first ensure you are on the target branch, then execute the extraction command. For example, to extract app.js file from experiment branch to main branch:

git checkout main
git checkout experiment -- app.js

This command copies the latest version of app.js file from experiment branch to the current working directory and automatically updates the staging area. Note that the file path should be relative to the repository root directory and should not contain leading slashes.

Modern Method: git restore Command in Git 2.23

With the release of Git 2.23, git switch and git restore commands were introduced, splitting the functionality of git checkout to make operations clearer. The basic syntax for using git restore to extract files:

git restore --source <source-branch> -- <file-path>

Practical operation example:

git switch main
git restore --source experiment -- app.js

By default, git restore only updates the working tree. If you need to simultaneously update the index (i.e., restore file content and add it to staging area), use:

git restore --source experiment --staged --worktree -- app.js
# Short form:
git restore -s experiment -SW -- app.js

Alternative Approach: git show Command

The git show command provides another file extraction method, particularly suitable for situations requiring file content redirection to specific locations:

git show experiment:path/to/app.js > path/to/app.js

This method requires specifying the complete file path and does not automatically update the Git index, requiring manual execution of git add command to add the file to the staging area.

Advanced Techniques: Specific Version File Extraction

All the above methods support extracting files from specific revisions rather than the latest commit. By using Git's revision syntax, file versions can be precisely controlled:

git show $REVISION:$FILENAME
git checkout $REVISION -- $FILENAME

Revisions can be flexibly specified:

experiment@{yesterday}:app.js    # app.js as it was yesterday
experiment^:app.js               # app.js in the first parent commit
experiment@{2}:app.js            # app.js two commits ago

Extracting Files from Stash

In addition to file extraction between branches, files can also be restored from Git stash:

git checkout stash -- app.js

This is particularly useful when working on multiple branches and not wanting to commit intermediate states, allowing retrieval of required files without interrupting the current workflow.

Practical Application Scenario Analysis

Consider the following typical scenario: a developer working on feature/A branch needs to obtain an updated utils.js file from feature/B branch. Using the git checkout method:

git checkout feature/A
git checkout feature/B -- utils.js
git add utils.js
git commit -m "Update utils.js from feature/B branch"

This method avoids context interruption caused by branch switching, maintaining the continuity of the development process.

Considerations and Best Practices

When using these methods, note that: the source branch must be a local branch, remote branches need to be fetched locally first; file paths must be accurate, otherwise the operation will fail; extraction operations overwrite files with the same name in the current working directory, so it's recommended to backup important changes first.

Conclusion

Git provides multiple flexible methods for extracting single files from other branches, each with its applicable scenarios. The git checkout command has the best compatibility, the git restore command has clearer semantics, and the git show command is suitable for scripted operations. Mastering these techniques can significantly improve version control efficiency, reducing unnecessary branch switching and context switching.