The Ultimate Git Command Guide for Developers in 2026: From Beginner to Pro 🚀

# List branches
git branch                          # Local branches
git branch -r                       # Remote branches
git branch -a                       # All branches
git branch -vv                      # With upstream info

# Create branch
git branch feature-login            # Create only
git checkout -b feature-login       # Create + switch (old syntax)
git switch -c feature-login         # Create + switch (new syntax, Git 2.23+)

# Switch branches
git checkout main                   # Old syntax
git switch main                     # New syntax (clearer)

# Delete branches
git branch -d feature-login         # Delete merged branch
git branch -D feature-login         # Force delete (ignore merge status)

# Rename branch
git branch -m old-name new-name

# Basic merge (performs fast-forward if possible)
git merge feature-branch

# Force non-fast-forward (creates merge commit)
git merge --no-ff feature-branch

# Abort merge
git merge --abort

# Merge with specific strategy
git merge -X ours feature-branch    # Prefer current branch on conflict
git merge -X theirs feature-branch  # Prefer target branch on conflict

# Rebase current branch onto main
git rebase main

# Interactive rebase (powerful!)
git rebase -i HEAD~5

# Continue rebase after resolving conflicts
git rebase --continue

# Abort rebase (restore original state)
git rebase --abort

# Rebase onto specific commit
git rebase --onto newbase oldbase branch

# Stash current changes
git stash
git stash push -m "WIP: implementing login feature"

# List stashes
git stash list
# stash@{0}: On main: WIP: implementing login feature
# stash@{1}: On feature-branch: temporary modifications

# Apply stash (without removing from list)
git stash apply
git stash apply stash@{1}

# Apply and remove stash (pop)
git stash pop
git stash pop stash@{0}

# Stash specific files only
git stash push -m "partial stash" path/to/file.txt

# Include untracked files
git stash push -u -m "including untracked"
git stash push --all  # Include ignored files too

# Extract specific file from stash
git checkout stash@{0} -- filename.txt

# Drop stash
git stash drop stash@{1}

# Clear all stashes
git stash clear

# Convert stash to new branch
git stash branch new-branch-name stash@{0}

# Single commit cherry-pick
git cherry-pick abc1234

# Multiple commits cherry-pick
git cherry-pick abc1234 def5678

# Range cherry-pick (older..newer)
git cherry-pick abc1234^..def5678

# Cherry-pick merge commit
git cherry-pick -m 1 abc1234

# Apply commit content only (without creating commit)
git cherry-pick -n abc1234

# During cherry-pick conflict
git cherry-pick --continue
git cherry-pick --abort
git cherry-pick --skip

# Check reflog
git reflog
git reflog --date=relative  # Show relative time

# Recover to specific point
git reset --hard HEAD@{2}
git reset --hard abc1234

# Recover deleted branch
git reflog | grep "checkout: moving from"
git branch recovered-branch HEAD@{5}

# Use ORIG_HEAD (before last dangerous operation)
git reset --hard ORIG_HEAD

# Specific branch reflog
git reflog show feature-branch

# Find unreachable objects
git fsck --unreachable --no-reflogs | grep commit

#!/bin/bash
# .git/hooks/pre-commit

echo "🔍 Running pre-commit checks..."

# Staged files list
STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(js|jsx|ts|tsx)$')

if [ -n "$STAGED_FILES" ]; then
    echo "Running ESLint..."
    npx eslint $STAGED_FILES --fix
    
    if [ $? -ne 0 ]; then
        echo "❌ ESLint failed. Commit aborted."
        exit 1
    fi
    
    # Re-stage modified files
    echo "$STAGED_FILES" | xargs git add
fi

# Check for debug code
if git diff --cached | grep -E "console\.log|debugger|TODO|FIXME"; then
    echo "⚠️ Warning: Debug code or TODOs found in staged changes"
    # exit 1  # Uncomment to force block
fi

echo "✅ Pre-commit checks passed!"
exit 0

#!/bin/bash
# .git/hooks/commit-msg

COMMIT_MSG_FILE=$1
COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")

# Check Conventional Commits pattern
PATTERN="^(feat|fix|docs|style|refactor|test|chore|ci|build|perf)(\(.+\))?: .{1,100}"

if ! echo "$COMMIT_MSG" | grep -qE "$PATTERN"; then
    echo "❌ Invalid commit message format!"
    echo ""
    echo "Expected format: (): "
    echo ""
    echo "Types: feat, fix, docs, style, refactor, test, chore, ci, build, perf"
    echo "Example: feat(auth): add JWT token validation"
    echo ""
    exit 1
fi

echo "✅ Commit message format valid!"
exit 0

# Create new worktree (auto-creates branch)
git worktree add ../project-feature feature-branch

# Existing branch to worktree
git worktree add ../project-hotfix hotfix-branch

# List worktrees
git worktree list

# Remove worktree
git worktree remove ../project-feature

# Remove unpruned worktrees
git worktree prune

# Create worktree with detached HEAD
git worktree add --detach ../project-temp

# Move to main worktree
cd $(git rev-parse --show-toplevel)

# Enable sparse checkout
git sparse-checkout init

# Set included directories
git sparse-checkout set frontend/app
git sparse-checkout set frontend/app backend/api

# Add multiple patterns
git sparse-checkout add shared/utils
git sparse-checkout add docs/

# Check current settings
git sparse-checkout list

# Disable (full checkout)
git sparse-checkout disable

# cone mode (better performance)
git sparse-checkout init --cone
git sparse-checkout set frontend backend

# macOS
brew install git-lfs
git lfs install

# Ubuntu/Debian
curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
sudo apt-get install git-lfs
git lfs install

# Windows
winget install GitHub.GitLFS
git lfs install

# Per-repository setup
git lfs install --local

# Track file patterns
git lfs track "*.psd"
git lfs track "*.zip"
git lfs track "*.mp4"
git lfs track "assets/videos/**"
git lfs track "data/*.csv"

# .gitattributes is auto-generated
cat .gitattributes
# *.psd filter=lfs diff=lfs merge=lfs -text

# Must commit .gitattributes
git add .gitattributes
git commit -m "Configure Git LFS"

# Add large files
git add design/mockup.psd
git commit -m "Add mockup design"
git push

# Generate SSH key (Ed25519 recommended)
ssh-keygen -t ed25519 -C "your@email.com" -f ~/.ssh/git_signing_key

# Git configuration
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/git_signing_key.pub
git config --global commit.gpgsign true  # Auto-sign all commits

# Or for specific repository only
git config commit.gpgsign true

# Setup allowed_signers file (for signature verification)
echo "$(git config user.email) namespaces=\"git\" $(cat ~/.ssh/git_signing_key.pub)" > ~/.ssh/allowed_signers
git config --global gpg.ssh.allowedSignersFile ~/.ssh/allowed_signers

# ~/.gitconfig
[alias]
    # Basic shortcuts
    st = status
    co = checkout
    sw = switch
    br = branch
    ci = commit
    cm = commit -m
    
    # Powerful shortcuts
    amend = commit --amend --no-edit
    unstage = restore --staged
    last = log -1 HEAD
    visual = !gitk
    
    # Pretty logs
    lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
    lol = log --graph --decorate --oneline --all
    
    # Add + commit + push at once
    acp = "!f() { git add -A && git commit -m \"$1\" && git push; }; f"
    amod = "!f() { git add -u && git commit -m \"$1\" && git push; }; f"
    
    # Safe updates
    up = "!git fetch --prune && git rebase origin/$(git rev-parse --abbrev-ref HEAD)"
    sync = "!git fetch --all --prune"
    
    # Dangerous but useful
    nuke = reset --hard
    undo = reset --soft HEAD~1
    
    # Stash shortcuts
    ss = stash
    sp = stash pop
    sl = stash list
    
    # Current branch related
    current = rev-parse --abbrev-ref HEAD
    upstream = rev-parse --abbrev-ref --symbolic-full-name @{u}

# Situation: Should have worked on feature-A branch but committed to main

# 1. Temporarily store the commit
git reset --soft HEAD~1

# 2. Move to correct branch (or create)
git switch -c feature-A

# 3. Recreate commit
git commit -m "feat: implement feature A"

# Or use cherry-pick
git switch -c feature-A
git cherry-pick main  # Last commit from main
git switch main
git reset --hard HEAD~1  # Remove commit from main

# Method 1: Amend last commit (if not pushed yet)
git reset --soft HEAD~1
# Edit files
git add .
git commit -m "fixed: remove sensitive data"

# Method 2: Rewrite entire history (if already pushed - caution!)
git filter-repo --path config/secrets.json --invert-paths
# Or
git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch config/secrets.json" \
  --prune-empty --tag-name-filter cat -- --all

# Method 3: BFG Repo-Cleaner (for large repos)
bfg --delete-files secrets.json
git reflog expire --expire=now --all
git gc --prune=now --aggressive

# 1. Check for conflicts
git status
# Unmerged paths: both modified: src/app.js

# 2. Check conflict markers
cat src/app.js
# <<<<<<< HEAD
# my code
# =======
# their code
# >>>>>>> feature-branch

# 3. Edit manually or use tool
git mergetool  # Open configured tool (vimdiff, vscode, etc.)

# 4. Mark as resolved
git add src/app.js

# 5. Complete merge
git commit  # Auto-creates merge commit

# Or if rebasing
git rebase --continue

# Abort merge
git merge --abort
git rebase --abort

# Situation: Checked out specific commit, HEAD is detached
# HEAD is now at abc1234...

# If no changes: simply return to branch
git switch main

# If there are changes
# Method 1: Create new branch (recommended)
git switch -c new-branch-name

# Method 2: Merge into existing branch
git switch main
git merge $(git rev-parse HEAD)
git branch -d temp-branch