For developers working in Windows environments, Git Bash offers a powerful bridge between the Unix command line world and Windows operating systems. This guide will walk you through essential Git Bash commands, practical workflows, and time-saving techniques that will transform how you interact with your code repositories.
Git Bash serves as a command-line terminal for Windows users that combines Git functionality with the Unix Bash shell environment. Unlike the standard Windows Command Prompt, Git Bash provides access to both Git commands and Unix utilities, creating a consistent environment across different operating systems.
At its core, Git Bash offers:
For Windows developers, Git Bash eliminates the barrier between operating systems, providing the same powerful command-line tools that macOS and Linux users enjoy. Rather than switching contexts between different command interfaces, Git Bash creates a unified experience.
Before diving into commands, let's ensure your Git Bash environment is properly configured.
When using Git for the first time, set up your identity:
# Set your username
git config --global user.name "Your Name"
# Set your email
git config --global user.email "youremail@example.com"
# Verify your settings
git config --list
Make Git Bash your own with these customizations:
# Enable colorful output
git config --global color.ui auto
# Set your preferred text editor
git config --global core.editor "code --wait" # For VS Code
For a more informative prompt, create or edit your .bash_profile file to show your current branch:
# Add this to your .bash_profile
parse_git_branch() {
git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
}
export PS1="\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\[\033[32m\]\$(parse_git_branch)\[\033[m\]$ "
Git Bash's power begins with basic file system navigation and management.
# Show current directory
pwd
# List files and directories
ls
ls -la # Show hidden files and details
# Change directory
cd project-folder
cd .. # Go up one level
cd ~ # Go to home directory
cd /c/ # Access C: drive
# Create a new directory
mkdir new-project
# Create a new file
touch README.md
# Copy files
cp original.txt copy.txt
cp -r source-folder/ destination-folder/ # Copy directory
# Move or rename files
mv oldname.txt newname.txt
mv file.txt /path/to/destination/
# Delete files and directories
rm unwanted.txt
rm -rf old-directory/ # Be careful with this!
# View file content
cat config.json
# View file with pagination
less large-file.log
# Search for text in files
grep "function" *.js
grep -r "TODO" . # Search recursively in current directory
These commands form the foundation of Git operations in your daily workflow.
# Initialize a new repository
git init
# Clone an existing repository
git clone https://github.com/username/repository.git
# Clone to a specific folder
git clone https://github.com/username/repository.git custom-folder-name
# Check repository status
git status
# Add files to staging area
git add filename.txt # Add specific file
git add . # Add all changes
git add *.js # Add all JavaScript files
git add src/ # Add entire directory
# Commit changes
git commit -m "Add user authentication feature"
# Amend the last commit
git commit --amend -m "Updated message"
# View commit history
git log
# Compact view of history
git log --oneline
# Graph view with branches
git log --graph --oneline --decorate
# View changes in a commit
git show commit-hash
# View changes between commits
git diff commit1..commit2
Branching is where Git's power truly shines, allowing parallel development streams.
# List all branches
git branch # Local branches
git branch -r # Remote branches
git branch -a # All branches
# Create a new branch
git branch feature-login
# Create and switch to a new branch
git checkout -b feature-payment
# Switch branches
git checkout main
# Rename a branch
git branch -m old-name new-name
# Delete a branch
git branch -d feature-complete
git branch -D feature-broken # Force delete
# Merge a branch into current branch
git merge feature-complete
# Merge with no fast-forward (creates a merge commit)
git merge --no-ff feature-login
# Rebase current branch onto another
git rebase main
# Interactive rebase to clean up commits
git rebase -i HEAD~5
Connect your local work with remote repositories for collaboration.
# List remote repositories
git remote -v
# Add a remote
git remote add origin https://github.com/username/repo.git
# Change remote URL
git remote set-url origin https://github.com/username/new-repo.git
# Remove a remote
git remote remove upstream
# Download changes without merging
git fetch origin
# Download and merge changes
git pull origin main
# Upload local changes
git push origin feature-branch
# Set up branch tracking
git branch --set-upstream-to=origin/main main
Save precious keystrokes with Git aliases and Bash shortcuts.
Add these to your .gitconfig file:
[alias]
# Status, add, and commit shortcuts
s = status
a = add
aa = add --all
c = commit -m
ca = commit --amend
# Branch operations
b = branch
co = checkout
cob = checkout -b
# History viewing
l = log --oneline --graph --decorate --all
ld = log --pretty=format:"%C(yellow)%h%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate
# Useful combinations
save = !git add --all && git commit -m 'SAVEPOINT'
undo = reset HEAD~1 --mixed
wipe = !git add --all && git commit -qm 'WIPE SAVEPOINT' && git reset HEAD~1 --hard
Add these to your .bash_profile or .bashrc:
# Quick status check
alias gs='git status'
# Branch management
alias gb='git branch'
alias gba='git branch -a'
alias gbd='git branch -d'
# Checkout shortcuts
alias gco='git checkout'
alias gcb='git checkout -b'
alias gcm='git checkout main'
# Pull and push simplified
alias gpl='git pull'
alias gps='git push'
alias gpom='git push origin main'
# Log visualization
alias glog='git log --oneline --graph --decorate'
alias gloga='git log --oneline --graph --decorate --all'
Level up your Git Bash skills with these powerful techniques.
# Save changes temporarily
git stash
# Save with a description
git stash push -m "Work in progress for feature X"
# List all stashes
git stash list
# Apply most recent stash
git stash apply
# Apply specific stash
git stash apply stash@{2}
# Apply and remove from stash list
git stash pop
# Remove a stash
git stash drop stash@{0}
# Clear all stashes
git stash clear
# Search commit messages
git log --grep="bug fix"
# Find who changed a line
git blame filename.js
# Find when a function was added/removed
git log -L :functionName:filename.js
# Find branches containing a commit
git branch --contains commit-hash
# Find all commits that modified a file
git log -- filename.txt
# Cherry-pick a commit
git cherry-pick commit-hash
# Revert a commit
git revert commit-hash
# Interactive rebase for cleanup
git rebase -i HEAD~5
# View reflog (history of HEAD changes)
git reflog
# Reset to a previous state
git reset --soft HEAD~3 # Keep changes staged
git reset --mixed HEAD~3 # Keep changes unstaged
git reset --hard HEAD~3 # Discard changes (careful!)Git Bash excels at solving common Git predicaments.
# Forgot to add a file to commit
git add forgotten-file.txt
git commit --amend --no-edit
# Committed to wrong branch
git branch correct-branch # Create the right branch
git reset HEAD~ --soft # Undo the commit but keep changes
git stash # Stash the changes
git checkout correct-branch
git stash pop # Apply changes to correct branch
git add . # Stage changes
git commit -m "Commit message" # Commit to correct branch
# When merge conflict occurs
git status # Check which files have conflicts
# After manually resolving conflicts
git add resolved-file.txt
git commit # Completes the merge
For more complex conflicts:
# Use merge tool
git mergetool
# Abort a problematic merge
git merge --abort
# Find deleted commits with reflog
git reflog
# Restore lost commit
git checkout commit-hash
# Create branch from detached HEAD
git checkout -b recovery-branch
While graphical Git clients are convenient, Git Bash provides superior capabilities in several scenarios:
Scenario: Cleanup branches after sprint completion
GUI approach: Manually select and delete each branch - tedious and error-prone.
Git Bash solution:
# Delete all local branches that have been merged to main
git checkout main
git branch --merged | grep -v "main" | xargs git branch -d
Scenario: Find who introduced a bug and when
GUI approach: Scroll through commit history hoping to spot the culprit.
Git Bash solution:
# Find when a line was changed
git blame -L15,25 problematic-file.js
# Find commits mentioning the feature
git log --grep="feature name"
# Find commits that changed specific functions
git log -p -S "functionName"
Scenario: Standardize commit formatting for team
GUI approach: Distribute written guidelines and hope team follows them.
Git Bash solution:
# Set up a commit template
git config --global commit.template ~/.gitmessage
# Create ~/.gitmessage with your template
# Then add a pre-commit hook to enforce standards
These examples demonstrate how Git Bash can handle complex scenarios more efficiently than GUI tools, especially for batch operations, deep repository analysis, and customized workflows.
Git Bash provides a Unix-like shell environment on Windows, including Bash commands (like grep, ls, and cd) that work differently from their CMD equivalents. It also comes pre-loaded with Git commands and supports Unix-style paths using forward slashes, making it more consistent with macOS and Linux environments.
While GUI clients are user-friendly, Git Bash offers powerful capabilities for complex operations, scripting, and automation that most GUIs can't match. Even if you primarily use a GUI, learning Git Bash gives you a fallback for situations where the GUI is insufficient or unavailable.
Windows: Download Git for Windows from git-scm.com, which includes Git Bash.
macOS: Git Bash isn't necessary since macOS already has a Unix-based Terminal. Install Git via Homebrew with brew install git.
Linux: Similarly, Linux distributions have native Bash terminals. Install Git with your package manager (e.g., apt-get install git for Ubuntu).
No! Git Bash provides a full Bash shell environment. You can use it for any command-line tasks, including file management, text processing, and running scripts—even in projects that don't use Git.
Set up credential storage with:
# Cache credentials for 15 minutes
git config --global credential.helper cache
# Store credentials permanently
git config --global credential.helper store
# Use Windows credential manager
git config --global credential.helper wincred
Yes, you can set up SSH keys for different accounts and create a config file to specify which key to use for which repository. This allows you to manage multiple accounts without constant credential switching.
By mastering Git Bash commands, you'll gain powerful tools that extend far beyond basic version control. The command line gives you precision, automation, and deep insight into your repositories that point-and-click interfaces simply can't match. Start with the basics, gradually incorporate more advanced commands, and soon you'll find Git Bash becoming an indispensable part of your development workflow.
Whether you're resolving complex merge conflicts, automating repetitive tasks, or diving deep into your project's history, Git Bash provides the tools you need to work efficiently and effectively. Embrace the command line, and watch your productivity soar.
Implement engineering metrics, gather SDLC insights & set continuous improvement goals in your dev teams.
Try Live Demo
