You’re in the middle of a critical bug fix. You need to create a new branch, but you can’t remember: is it git checkout-b or git branch-b? You Google it for the hundredth time this month.
Sound familiar? Git has 160+ commands, and even experienced developers constantly look up the syntax.
This Git commands cheat sheet solves that problem. It’s the most comprehensive, modern reference for Git commands you actually use, organized by what you’re trying to accomplish, not alphabetical order.
What makes this different:
- ✅ Modern syntax (Git 2.23+ commands like
git switchandgit restore) - ✅ 50+ code examples (copy-paste ready)
- ✅ Workflow-focused (organized by task, not alphabetically)
- ✅ Troubleshooting (common mistakes and how to fix them)
Quick Navigation
Branch Management
Creating and Switching Branches
Create a new branch and switch to it:
git checkout -b feature-nameThis is the most common branching command. It combines two operations:
- Creates the branch:
git branch feature-name - Switches to it:
git checkout feature-name
💡 Modern (Git 2.23+): git switch -c feature-name
The switch command is clearer, it only handles branches, while checkout does multiple things.
Create a branch from another branch:
git checkout -b new-branch existing-branch
# Example: Create feature branch from develop
git checkout -b feature/user-auth developSwitching Between Branches
Switch to an existing branch:
git checkout branch-name
# Modern: git switch branch-nameSwitch to the previous branch:
git checkout -This is like the “back” button in your browser, super useful when switching between two branches frequently.
Checking Current Branch
# Full status
git status
# Just branch name
git branch --show-currentStaging & Committing
Checking Status
git status # Full status
git status -s # Short formatStaging Files
# Stage a specific file
git add filename.js
# Stage all changes
git add .
# Stage all JS files
git add *.js
# Stage parts of a file (interactive)
git add -p filename.jsUnstaging Files
# Modern way (Git 2.23+)
git restore --staged filename.js
# Old way (still works)
git reset HEAD filename.jsDiscarding Changes
# Discard changes in a file (modern)
git restore filename.js
# Discard ALL changes
git reset --hard HEAD⚠️ Warning: git reset --hard permanently deletes changes!
Undoing Changes
Removing Commits
# Delete last commit (keep changes)
git reset --soft HEAD~1
# Delete last commit (discard changes)
git reset --hard HEAD~1
# Delete last 3 commits
git reset --hard HEAD~3Resetting to Remote
# Reset to match remote
git fetch origin
git reset --hard origin/main
# Shorthand
git reset --hard @{u}Undoing Merges
# Undo merge (if not committed)
git merge --abort
# Undo merge (if already committed)
git reset --hard HEAD~1Remote Operations
Cloning
# Clone repository
git clone https://github.com/user/repo.git
# Clone specific branch
git clone -b branch-name https://github.com/user/repo.git
#Shallow clone (faster for large repos)
git clone --depth 1 https://github.com/user/repo.gitPulling and Pushing
# Pull from current branch
git pull
# Pull from another branch
git pull origin branch-name
# Pull with rebase (cleaner history)
git pull --rebase
# Push and set upstream
git push -u origin branch-name
# Force push (dangerous - use with caution)
git push --force
# Safer force push
git push --force-with-leaseMoving Commits Between Branches
# On wrong branch
git reset HEAD~1 --soft
git stash
# Switch to correct branch
git checkout correct-branch
git stash pop
git commit -m "Your message"Viewing History
Logs
git log
git log -5 # Last 5 commits
git log --oneline # Compact format
git log -p # See changes in each commit
git log --author="John Doe" # By author
git log --since="2 weeks ago" # Date rangeDiffs
git diff # Unstaged changes
git diff --staged # Staged changes
git diff origin/main # Compare with remote
git diff --name-only # List changed filesAdvanced Operations
Stashing
git stash
git stash save "Work in progress"
git stash --staged # Stash only staged changes
git stash -u # Include untracked files
git stash list
git stash pop
git stash apply stash@{2}
git stash drop stash@{0} # Delete a stash
git stash clear # Clear all stashesConfiguration
git config --list
git config --global user.name "Your Name"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global color.ui autoRemoving Files
# Remove file from Git (keep locally)
git rm --cached filename.js
# Remove directory recursively
git rm -r directory-nameCommon Workflows
Starting a New Feature
# 1. Update main
git checkout main
git pull origin main
# 2. Create feature branch
git checkout -b feature/new-feature
# 3. Make changes and commit
git add .
git commit -m "Add feature"
# 4. Push
git push -u origin feature/new-featureFixing: Committed to Wrong Branch
# On wrong branch
git reset HEAD~1 --soft
git stash
# Switch to correct branch
git checkout correct-branch
git stash pop
git commit -m "Your message"Resolving Merge Conflicts
# 1. Pull latest changes
git pull origin main
# 2. Conflicts appear
# CONFLICT (content): Merge conflict in src/app.js
# 3. Edit conflicted files
# ... resolve conflicts ...
# 4. Stage resolved files
git add src/app.js
# 5. Complete the merge
git commit -m "Resolve merge conflicts"Modern Git (2.23+)
Git 2.23 (August 2019) introduced clearer commands to replace confusing ones.
The Problem with git checkout
git checkout does three different things:
- Switch branches:
git checkout branch-name - Restore files:
git checkout -- filename - Create and switch:
git checkout -b new-branch
This is confusing! The new commands are clearer.
Old vs. New Syntax
| Task | Old Command | New Command (Git 2.23+) |
|---|---|---|
| Switch to existing branch | git checkout branch | git switch branch |
| Create and switch to new branch | git checkout -b branch | git switch -c branch |
| Discard changes in file | git checkout -- file | git restore file |
| Unstage file | git reset HEAD file | git restore --staged file |
Git Terminology
| Term | Definition |
|---|---|
| HEAD | Pointer to current commit |
| origin | Default remote repository |
| main/master | Default branch name |
| upstream | Original repository (for forks) |
| staged | Changes ready to commit |
| commit | Snapshot of code |
| branch | Parallel version of code |
| merge | Combine two branches |
| rebase | Rewrite commit history |
| stash | Temporarily save changes |
| clone | Copy repository locally |
| fork | Copy someone’s repository |
Frequently Asked Questions
What does git checkout -b do?
git checkout -b branch-name creates a new branch and immediately switches to it. The modern equivalent is git switch -c branch-name.
How do I unstage a file?
Modern: git restore --staged filename
Old: git reset HEAD filename
How to check current branch?
git status or git branch --show-current
How do I delete a commit?
Keep changes: git reset --soft HEAD~1
Discard: git reset --hard HEAD~1
How do I clone a specific branch?
git clone -b branch-name https://github.com/user/repo.gitWhat’s the difference between git reset and git revert?
git reset: Moves the branch pointer backward, rewrites history. ⚠️ Don’t use on pushed commits.
git revert: Creates a new commit that undoes changes. ✅ Safe for pushed commits.
How do I discard all local changes?
# Discard unstaged changes
git restore .
# Discard all changes
git reset --hard HEAD
# Match remote exactly
git fetch origin
git reset --hard origin/mainThe Bottom Line
Git is powerful but complex. You don’t need to memorize every command—you just need a reliable reference.
Bookmark this page. The next time you’re stuck on Git syntax, you’ll have the answer in seconds.
Most-Used Commands (In Order)
git status– Check what’s changedgit checkout -b/git switch -c– Create and switch to a branchgit add .– Stage all changesgit commit -m– Commit with a messagegit push– Push to remotegit pull– Pull from remotegit reset --hard– Discard all changesgit stash– Save work in progress
Master these 8, and you’ll handle 90% of your daily Git work.
