Git Complete Guide — What, Why, How, and When to Use Every Command

# Configure your identity (once per machine — appears in every commit)
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Set default branch name to main (modern convention)
git config --global init.defaultBranch main

# Set preferred editor for commit messages
git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"           # Vim

# Initialize a new repo in current directory
git init

# Clone an existing repo (downloads entire history)
git clone https://github.com/user/repo.git

# Clone into a specific folder name
git clone https://github.com/user/repo.git my-folder

# Check what's changed (always run this before staging)
git status

# See the actual diff — what changed in tracked files (unstaged)
git diff

# See diff of staged changes (what will go into next commit)
git diff --staged

# Stage specific files
git add file.js
git add src/components/Button.tsx

# Stage everything in current directory (use carefully)
git add .

# Interactively stage specific hunks (HIGHLY recommended!)
# Lets you review each change before staging it
git add -p

# Commit with message on command line
git commit -m "feat: add user authentication"

# Stage all tracked files AND commit in one step
# (does NOT stage new untracked files)
git commit -am "fix: correct null check in user service"

# View commit history
git log

# Compact one-line view (most useful)
git log --oneline

# With branch graph visualization
git log --oneline --graph --all

# See what files changed in each commit
git log --stat

# List all local branches (* marks current branch)
git branch

# List all branches including remote-tracking branches
git branch -a

# Create a new branch (stays on current branch)
git branch feature/user-auth

# Create AND switch to new branch (most common workflow)
git checkout -b feature/user-auth

# Modern equivalent (Git 2.23+)
git switch -c feature/user-auth

# Switch to an existing branch
git checkout main
git switch main    # modern equivalent

# Rename current branch
git branch -m new-name

# Delete a merged branch (safe — fails if unmerged)
git branch -d feature/user-auth

# Force delete (even if unmerged — permanent data loss risk!)
git branch -D feature/user-auth

# Merge a branch into current branch
git checkout main
git merge feature/user-auth

# Merge with no fast-forward (always create a merge commit)
git merge --no-ff feature/user-auth

# See which branches are merged into current branch
git branch --merged

# See which branches are NOT yet merged
git branch --no-merged

# On your feature branch, update it with latest main:
git checkout feature/my-feature
git rebase main   # replays your commits on top of latest main

# If conflicts arise during rebase:
# 1. Fix the conflict in the file
git add conflicted-file.js
git rebase --continue

# Abort the entire rebase (restore to pre-rebase state)
git rebase --abort

# Interactive rebase — squash, edit, reorder, drop commits:
git rebase -i HEAD~3   # edit the last 3 commits interactively
# In the editor: pick / squash / reword / edit / drop

# Squash all feature branch commits into one before merging:
# From main:
git merge --squash feature/my-feature
git commit -m "feat: complete user authentication feature"

# Discard unstaged changes in a specific file
git restore file.js
git checkout -- file.js   # older syntax (same effect)

# Discard ALL unstaged changes (irreversible!)
git restore .

# Unstage a file (move from staging back to working dir)
git restore --staged file.js
git reset HEAD file.js   # older syntax

# Unstage everything
git restore --staged .

# Amend the last commit message
git commit --amend -m "corrected commit message"

# Add forgotten file to last commit (same message)
git add forgotten-file.js
git commit --amend --no-edit

# Revert a specific commit (creates an undo commit)
git revert abc1234

# Reset to 1 commit back — keep changes staged
git reset --soft HEAD~1

# Reset to 1 commit back — keep changes in working dir (default)
git reset HEAD~1
git reset --mixed HEAD~1

# Reset to 1 commit back — DISCARD all changes (DANGEROUS!)
git reset --hard HEAD~1

# Recover deleted commits via reflog (within ~30 days)
git reflog                         # find lost commit hash
git checkout -b recovery abc1234   # create branch at lost commit

# List remotes with their URLs
git remote -v

# Add a remote (origin is the conventional default name)
git remote add origin https://github.com/user/repo.git

# Change a remote URL (e.g. after renaming a repo)
git remote set-url origin https://github.com/user/new-name.git

# Fetch changes from remote WITHOUT merging
git fetch origin

# Compare your local main with remote after fetching
git diff main origin/main

# Pull = fetch + merge (most common)
git pull origin main

# Pull with rebase instead of merge (linear history)
git pull --rebase origin main

# Push your branch to remote
git push origin feature/my-feature

# Push and set upstream tracking (first push of a new branch)
git push -u origin feature/my-feature
# After -u is set, you can just run: git push

# Delete a remote branch
git push origin --delete feature/old-branch

# Stash current changes (tracked files only)
git stash

# Stash with a descriptive message
git stash push -m "WIP: half-done auth refactor"

# Stash including untracked new files
git stash push -u -m "WIP: new feature including new files"

# List all stashes
git stash list
# → stash@{0}: WIP: half-done auth refactor
# → stash@{1}: WIP on main: abc1234 prev commit

# Apply the most recent stash (keeps it in stash list)
git stash apply

# Apply AND remove from stash list
git stash pop

# Apply a specific stash by index
git stash apply stash@{2}

# Show what a stash contains
git stash show stash@{0}
git stash show -p stash@{0}   # with full diff

# Drop a specific stash
git stash drop stash@{0}

# Drop all stashes
git stash clear

# List all tags
git tag

# Create a lightweight tag (just a pointer to a commit)
git tag v1.0.0

# Create an annotated tag (recommended — stores metadata)
git tag -a v1.0.0 -m "Release version 1.0.0 — initial stable release"

# Tag a specific past commit
git tag -a v1.0.0 abc1234 -m "Release 1.0.0"

# Push a specific tag to remote
git push origin v1.0.0

# Push all tags to remote
git push origin --tags

# Delete a local tag
git tag -d v1.0.0

# Delete a remote tag
git push origin --delete v1.0.0

# Checkout the code at a specific tag (detached HEAD)
git checkout v1.0.0