How to create a Git branch from a specific previous commit
If I have a series of commits in my Git repository, how can I create a new branch that starts from a specific previous commit, such as the commit that is three positions back from the current HEAD (n-3)?
To create a Git branch from a specific previous commit, you can use the git branch command followed by the new branch name and the commit hash, or use git checkout -b with the commit hash. For a commit three positions back from HEAD (n-3), first identify the commit hash using git log --oneline -4 and then create the branch from that specific hash.
Contents
- Basic Branch Creation from Specific Commit
- Finding the Right Commit Hash
- Creating Branch from n-3 Position
- Advanced Branch Creation Techniques
- Common Use Cases and Examples
- Best Practices
Basic Branch Creation from Specific Commit
Creating a branch from a specific commit is a fundamental Git operation that allows you to isolate work at a particular point in your repository’s history. The basic syntax involves specifying the target commit hash when creating the branch.
The most direct method is using git branch:
git branch <new-branch-name> <commit-hash>
Or alternatively, using the git checkout command which creates and switches to the new branch in one step:
git checkout -b <new-branch-name> <commit-hash>
Both commands achieve the same result - they create a new branch that points to the specified commit, making it the HEAD of that branch. The commit hash uniquely identifies the exact commit you want to branch from, ensuring precision even in repositories with many similar commits.
Finding the Right Commit Hash
Before you can create a branch from a specific commit, you need to identify the commit hash of the target commit. There are several ways to find commit hashes in Git:
Using git log
The most common method is to use git log with various formatting options:
# Show last 10 commits with hashes
git log --oneline -10
# Show commits with full hash information
git log --oneline --format="%H %h %s"
# Show commits in a specific date range
git log --since="2024-01-01" --oneline
Using git rev-parse
For programmatic access to specific commit hashes:
# Get hash of current HEAD
git rev-parse HEAD
# Get hash of n-th parent commit
git rev-parse HEAD~3 # This gets the 3rd parent commit
Using git show
To see details about a specific commit and copy its hash:
git show --oneline HEAD~3
The commit hash is typically a 40-character hexadecimal string, but Git also accepts the shorter 7-character abbreviation as long as it’s unique within the repository.
Creating Branch from n-3 Position
To create a branch from the commit that is three positions back from the current HEAD (n-3), you can use Git’s special notation for parent commits.
Method 1: Using the ~ Notation
Git provides the ~ notation to reference parent commits. HEAD~3 refers to the third parent commit back from HEAD:
git checkout -b branch-from-n-3 HEAD~3
Or using git branch:
git branch branch-from-n-3 HEAD~3
Method 2: Using the ^ Notation
The ^ notation can also be used to navigate parent commits:
git checkout -b branch-from-n-3 HEAD^^^
Method 3: Finding the Hash First
If you prefer to work with the full hash for clarity:
# First find the hash of the n-3 commit
git log --oneline -4
# Then create the branch from that hash
git checkout -b branch-from-n-3 <commit-hash>
Method 4: Using git cherry-pick
If you want to create a branch that includes only specific commits up to the n-3 position:
# Create new branch from current HEAD
git checkout -b new-branch
# Reset back to n-3 commit, keeping changes
git reset --soft HEAD~3
# The branch now contains only the commits up to n-3
The ~ notation is particularly useful because it automatically calculates the correct commit hash, making your commands more readable and less prone to errors when you need to reference commits by their position relative to HEAD.
Advanced Branch Creation Techniques
Creating Branch from Remote Commit
If you need to create a branch from a commit that exists only on a remote repository:
# Fetch the latest from remote
git fetch origin
# Create branch from remote commit
git checkout -b local-branch origin/remote-branch~3
Creating Branch from Tag
When branching from a tagged commit:
git checkout -b branch-from-tag v1.2.3
Interactive Branch Creation
For more complex scenarios, you can use interactive rebase to selectively create branches:
# Start interactive rebase
git rebase -i HEAD~3
# This opens an editor where you can mark commits for
# different actions before creating branches
Using git worktree
For working with multiple branches simultaneously:
# Create a new worktree from specific commit
git worktree add -f ../branch-worktree HEAD~3
Branch Creation with Merge Strategy
When you need to create a branch with specific merge behavior:
# Create branch and set merge strategy
git checkout -b merge-branch HEAD~3
git config branch.merge-branch.mergeoption --no-ff
Common Use Cases and Examples
Hotfix Branch from Previous Release
# Find the release commit
git log --oneline --grep="Release v1.2.0"
# Create hotfix branch from that commit
git checkout -b hotfix-critical-bug abc1234
Feature Branch from Older State
# Create feature branch from stable version
git checkout -b feature-experiment stable-branch~5
Experimental Branch from Specific Test
# Find the test commit
git log --oneline --grep="Test: User Authentication"
# Create experimental branch
git checkout -b experimental-auth def5678
Branch for Rollback Scenario
# Create rollback branch before making changes
git checkout -b rollback-to-stable HEAD~3
# Make your risky changes
# If something goes wrong, you can reset to this branch
Branch for Code Review
# Create review branch from clean state
git checkout -b code-review-candidate HEAD~10
Each of these scenarios demonstrates how branching from specific commits provides precise control over your development workflow, allowing you to isolate changes at exactly the right point in your project’s history.
Best Practices
Naming Conventions
Use descriptive branch names that indicate both the purpose and the base commit:
# Good
git checkout -b feature-user-auth-fix HEAD~3
git checkout -b hotfix-security-patch origin/main~2
# Avoid
git checkout -b branch1 HEAD~3
git checkout -b x origin/main~2
Verification Before Branching
Always verify the target commit before creating the branch:
# Check the commit details
git show HEAD~3 --stat
# Verify the branch will start from the right place
git log --oneline HEAD~3..HEAD
Documentation
Document important branches with their base commits:
# Add branch description
git branch --edit-description branch-from-n-3
Cleanup
Regularly clean up old branches that were created from specific commits:
# List merged branches
git branch --merged
# Delete merged branches
git branch -d old-branch-from-specific-commit
Backup Strategy
When branching from older commits, consider:
- Backup: Make sure the target commit is well-tested
- Communication: Inform your team about the branch creation
- Integration: Plan how this branch will integrate with other work
By following these best practices, you ensure that your Git workflow remains organized, predictable, and efficient when working with branches created from specific commits.
Sources
- Official Git Documentation - git branch
- Official Git Documentation - git checkout
- Git Reference - revision selection
- Atlassian Git Tutorial - Branching
- Pro Git Book - Branch Management
Conclusion
Creating Git branches from specific commits is a powerful technique that gives you precise control over your development workflow. The key methods include using git branch or git checkout -b with commit hashes, or leveraging Git’s convenient ~ notation for relative positioning like HEAD~3.
Remember to always verify your target commit before creating branches, use descriptive naming conventions, and document important branch decisions. Whether you’re working on hotfixes, features, or experimental code, branching from specific commits ensures you start from exactly the right point in your project’s history.
For most use cases involving the n-3 position, the HEAD~3 notation provides the simplest and most readable solution. However, when you need absolute precision or are working with remote repositories, using the full commit hash offers the most reliable approach.
Mastering these techniques will significantly improve your Git workflow efficiency and help you maintain better control over your development process.