Git

Setup

git config --global user.name
                  "Name"

Set your name globally (used on all commits)

git config --global user.email
                  "email"

Set your email globally (appears in commit metadata)

git config --global core.editor
                  vim

Set default editor for commit messages and rebasing

git config --list Show all config values (global and local)

git config --local user.name
                  "Local Name"

Set name for current repo only (overrides global)

Init & Clone

git init Initialise a new repo in current directory

git clone <url> Clone a remote repo

git clone <url>
                  <dir>

Clone into a specific folder

git clone --depth 1
                  <url>

Shallow clone — latest commit only

Staging

git status Show working tree status

git add <file> Stage a specific file

git add . Stage all changes in current directory

git add -A Stage all changes everywhere (including deletions)

Interactively stage chunks — review each hunk before staging very useful for careful commits

git restore --staged
                  <file>

Unstage a file without discarding changes

git restore <file> Discard working directory changes destructive

Commits

git commit -m
                  "message"

Commit staged changes with a message

git commit -am
                  "message"

Stage all tracked file changes and commit in one step (modified files only)

git commit --amend Edit the last commit message or add staged changes without creating new commit rewrites history

git commit --amend --no-edit Add staged changes to last commit, keep original message

Branches

git branch List local branches — current marked with *

git branch -a List all branches (local and remote)

git branch <name> Create a new branch at current commit

git branch <name>
                  <commit>

Create branch from specific commit

git switch <name> Switch to a branch — working directory updates

git switch -c
                  <name>

Create and switch in one step (modern replacement for checkout -b)

git branch -m
                  <old>
                  <new>

Rename a branch

git branch -d
                  <name>

Delete a merged branch (safe — won't delete unmerged)

git branch -D
                  <name>

Force delete a branch destructive — discards work

git branch -v Show branches with last commit info

Merge & Rebase

git merge <branch> Merge branch into current — creates merge commit if branches diverged

git merge --no-ff
                  <branch>

Merge and always create a merge commit (for history)

git merge --squash
                  <branch>

Combine all commits from branch into one new commit

git rebase <branch> Replay current commits on top of another branch rewrites history — use only on unpushed commits

git rebase -i HEAD~n Interactive rebase — squash, reorder, edit, or drop commits

git rebase --continue Resume after resolving rebase conflicts

git rebase --abort Cancel an in-progress rebase and return to original state

git merge --abort Cancel an in-progress merge (useful during conflicts)

Remote

git remote List remote names (usually 'origin')

git remote -v List remotes with fetch/push URLs

git remote show origin Detailed info about a remote

git remote add
                  upstream <url>

Add a new remote (common for forks: upstream = original repo)

git fetch Download all remote changes without modifying working directory

git fetch <remote> Fetch from specific remote (e.g., upstream, origin)

git pull Fetch from upstream and merge into current branch

git pull --rebase Fetch and rebase instead of merge — cleaner linear history recommended for feature branches

git push Push current branch to its upstream remote

git push -u origin
                  <branch>

Push and set upstream tracking (do this first time per branch)

git push origin
                  feature-branch

Push specific branch to specific remote

git push --force-with-lease Safer force push — fails if remote has newer commits always use over --force

git push origin --delete
                  <branch>

Delete a remote branch

Log & Diff

git log Show commit history (newest first)

git log
                  --oneline --graph --all

Compact visual branch history with all branches

git log <branch> Show history of specific branch

git log -p
                  <file>

Show commit history with full diffs for a file

git log --since="2 weeks ago" Show commits since a specific time

git diff Show unstaged changes between working tree and index

git diff --staged Show staged changes (what's ready to commit)

git diff <branch1>..<branch2> Diff between two branches

git blame <file> Show who changed each line

Stash

git stash Stash current changes

git stash push -m
                  "message"

Stash with a label

git stash list List all stashes

git stash pop Apply latest stash and remove it

git stash apply stash@{n} Apply a specific stash without removing it

git stash drop stash@{n} Delete a specific stash

Undoing

git revert <hash> Create a new commit that undoes a commit — safe for shared branches

git reset --soft HEAD~1 Undo last commit, keep changes staged — good for amending

git reset --mixed HEAD~1 Undo last commit, keep changes unstaged (default) most common

git reset --hard HEAD~1 Undo last commit, discard all changes destructive — but reflog saves you

git reflog History of HEAD changes — recover lost commits from resets/rebases lifesaver for accidents

git reset --hard
                  <hash>

Reset to a specific commit (dangerous on shared branches)

git clean -fd Delete untracked files and directories destructive

git clean -n Preview what would be deleted (always check first!)

Cherry-pick & Tags

git cherry-pick <hash> Apply a specific commit to current branch

git cherry-pick <hash1>..<hash2> Apply a range of commits

git tag <name> Create a lightweight tag

git tag -a
                  <name>
                  -m
                  "msg"

Create an annotated tag

git push origin --tags Push all tags to remote

Search

git grep "pattern" Search working tree for a pattern

git log -S
                  "string"

Find commits that added or removed a string

git log --all --grep="message" Search commit messages

git bisect start Start binary search to find a bad commit

Undo Last Commit (Keep Changes)

Easy

Scenario: You committed too early and want to add more changes to the commit.

Step 1: Undo the commit, keep changes staged

git reset --soft HEAD~1

Step 2: Make your additional changes

git add <files>

Step 3: Commit again

git commit -m "Complete feature"

Alternative: Use git commit --amend to add staged changes to the last commit without creating a new one.

Made Commits on Wrong Branch

Medium

Scenario: You made commits on main but they should be on a feature branch.

Step 1: Create a new branch (keeps commits)

git branch feature-branch

Step 2: Reset main to before your commits

git reset --hard origin/main

Step 3: Switch to your feature branch

git switch feature-branch

Warning: Only use --hard if you're sure. It discards uncommitted changes.

Complete Feature Branch Workflow

Medium

Scenario: Full workflow from starting a feature to merging it back to main.

Step 1: Create feature branch from main

git switch main git pull origin main git switch -c feature/user-auth

Step 2: Make changes and commit

git add . git commit -m "Add login form"

Step 3: Keep pushing regularly

git push -u origin feature/user-auth

Step 4: Before PR, update from main

git fetch origin git rebase origin/main

Step 5: If someone else made changes

git push --force-with-lease origin feature/user-auth

Step 6: After PR is approved and merged

git switch main git pull origin main git branch -d feature/user-auth

Branch naming: Use descriptive names like feature/auth, bugfix/login-error, docs/readme

Update Feature Branch Before Pull Request

Medium

Scenario: Your feature branch is behind main/develop. You want to update it before creating a pull request to avoid merge conflicts.

Step 1: Ensure you're on your feature branch

git switch feature-branch

Step 2: Fetch latest from remote

git fetch origin

Step 3: Rebase option (cleaner history)

git rebase origin/main

Replays your commits on top of latest main

OR Merge option (preserves history)

git merge origin/main

Creates a merge commit if branches have diverged

Step 4: If conflicts during rebase

git rebase --abort

Cancel and try merge instead if needed

Step 5: Force push if rebased

git push --force-with-lease origin feature-branch

Only if you already pushed this branch

Rebase vs Merge: Rebase keeps a linear history (preferred for PRs), while merge preserves the full history. Check your team's preference.

Resolve Merge Conflicts

Medium

Scenario: You tried to merge and got conflicts.

Step 1: See which files have conflicts

git status

Step 2: Open conflicted files and look for markers

<<<<<<< HEAD
Your changes
=======
Their changes
>>>>>>> branch-name

Step 3: Edit files to resolve conflicts

Remove conflict markers and keep the code you want

Step 4: Mark as resolved

git add <resolved-files>

Step 5: Complete the merge

git commit

Abort: If you want to cancel the merge: git merge --abort

Recover Deleted File

Easy

Scenario: You deleted a file and want it back.

If not yet committed:

git restore <file>

If already committed (get from last commit):

git checkout HEAD~1 -- <file>

Find when file was deleted:

git log --all --full-history -- <file>

Undo a Commit That's Been Pushed

Medium

Scenario: You pushed a bad commit and need to undo it safely.

Step 1: Find the commit hash

git log --oneline

Step 2: Create a new commit that undoes it

git revert <commit-hash>

Step 3: Push the revert

git push

Why revert? Using git revert is safer than git reset for shared branches because it preserves history.

Save Work to Switch Branches

Easy

Scenario: You're working on something but need to switch branches urgently.

Step 1: Stash your changes

git stash push -m "WIP: feature description"

Step 2: Switch branches and do your work

git switch other-branch

Step 3: Return to original branch

git switch original-branch

Step 4: Restore your work

git stash pop

View stashes: git stash list

Sync Fork with Original Repo

Medium

Scenario: Your fork is behind the original repository.

Step 1: Add upstream remote (once)

git remote add upstream <original-repo-url>

Step 2: Fetch upstream changes

git fetch upstream

Step 3: Merge upstream into your branch

git merge upstream/main

Step 4: Push updates to your fork

git push origin main

Remove Untracked Files

Easy

Scenario: You have generated files or build artifacts to clean up.

Step 1: Preview what will be deleted

git clean -n

Step 2: Delete untracked files

git clean -f

Step 3: Also remove directories

git clean -fd

Warning: git clean permanently deletes files. Always preview with -n first!

Clean Up Commit History

Hard

Scenario: You have multiple messy commits that should be squashed before merging.

Step 1: Start interactive rebase

git rebase -i HEAD~3

Replace 3 with number of commits to edit

Step 2: In the editor, change 'pick' to 'squash'

pick abc123 First commit
squash def456 Fix typo
squash ghi789 Another fix

Step 3: Save and edit the combined commit message

Step 4: Force push if already pushed

git push --force-with-lease

Warning: Never rebase commits that others are working on!

Recover Lost Commits

Hard

Scenario: You did a hard reset or rebase and lost commits you need.

Step 1: View reflog (history of HEAD)

git reflog

Step 2: Find the commit you want

Look for the commit hash before the mistake

Step 3: Create a branch at that commit

git branch recovery <commit-hash>

Step 4: Or reset to that commit

git reset --hard <commit-hash>

Reflog saves you: Git keeps reflogs for 90 days by default, so lost commits can usually be recovered!

Fix Wrong Author on Commit

Medium

Scenario: You committed with the wrong name/email.

For the last commit only:

git commit --amend --author="Name
                    <email@example.com>"

Set correct user for this repo:

git config user.name "Your Name"git config user.email "email@example.com"

If already pushed:

git push --force-with-lease

Move Specific Commits to Another Branch

Medium

Scenario: You want specific commits from one branch on another branch.

Step 1: Find commit hashes

git log --oneline

Step 2: Switch to target branch

git switch target-branch

Step 3: Cherry-pick the commits

git cherry-pick <commit-hash>

For multiple commits:

git cherry-pick <hash1> <hash2>
                    <hash3>

Handle Rebase Conflicts

Medium

Scenario: During a rebase, you have conflicts that need resolving.

Step 1: Check status

git status

See which files have conflicts

Step 2: Edit conflicted files

Look for <<<<<<< marks and resolve manually

Step 3: Mark as resolved

git add <resolved-files>

Step 4: Continue the rebase

git rebase --continue

Step 5: If multiple conflicts per file

Repeat steps 2-4 for each conflict batch

Abort if stuck: git rebase --abort to cancel and start over

Keep Your Main Branch Clean

Easy

Scenario: You accidentally made commits on main but want them on a feature branch instead.

Step 1: Create feature branch with your commits

git branch feature/my-changes

Step 2: See how many commits to undo

git log --oneline -5

Step 3: Reset main to origin

git reset --hard origin/main

Step 4: Switch to your feature branch

git switch feature/my-changes

Step 5: Push new feature branch

git push -u origin feature/my-changes

Key benefit: Keep main in sync with origin/main so CI/CD and deploys stay reliable

Interactive Rebase: Squash, Reorder, Edit Commits

Hard

Scenario: You have messy commits with typo fixes and incremental changes. You want to clean them up into logical commits before merging.

Step 1: Start interactive rebase

git rebase -i HEAD~5

Edit last 5 commits

Step 2: In your editor, you'll see:

pick abc123 Add user model
pick def456 Fix typo in model
pick ghi789 Add validation
pick jkl012 Fix validation bug
pick mno345 Update docs

Step 3: Modify commands as needed:

pick abc123 Add user model
squash def456 Fix typo in model
pick ghi789 Add validation
squash jkl012 Fix validation bug
reword mno345 Update docs

Commands: pick (keep), squash (merge with previous), reword (edit message), drop (remove)

Step 4: Save and edit combined messages

For squashed commits, edit the final commit message

Step 5: Force push if already pushed

git push --force-with-lease

Team rule: Never rebase commits that teammates are actively working on

Find and Debug: Blame, Log Search, and Bisect

Medium

Scenario: A bug appeared and you need to find which commit introduced it.

Step 1: See who changed a specific line

git blame src/auth.js

Shows commit hash and author for each line

Step 2: Find commits by message

git log --all --grep="auth fix"

Step 3: Find commits that changed specific string

git log -S "validatePassword" -p

Shows commits where this string was added or removed

Step 4: Binary search for the bad commit

git bisect start git bisect bad git bisect good v1.0

Step 5: Test current commit and mark it

git bisect good or git bisect bad

Git narrows down the commit automatically

View specific commit: git show <commit-hash> to see full changes

Manage Multiple Remotes and Branches

Medium

Scenario: You work with forks, multiple repos, or need to pull from different sources.

Step 1: List all remotes

git remote -v

Step 2: Add upstream, fork, or team remote

git remote add upstream <original-repo> git remote add team-repo <team-url>

Step 3: Fetch from all remotes

git fetch --all

Step 4: Check out branch from specific remote

git switch --track upstream/feature-x

Step 5: View all branches everywhere

git branch -a

Shows local and remote branches

Step 6: Pull from upstream, push to origin

git pull upstream develop git push origin develop

Undo Multiple Commits Safely

Hard

Scenario: The last 3 commits are wrong but you want to keep them to investigate, or revert them safely on a shared branch.

Option 1: Soft reset (keep changes)

git reset --soft HEAD~3

Undo commits but keep changes staged for re-committing

Option 2: Revert for shared branches

git revert HEAD~2..HEAD

Creates new commits that undo the old ones (safe for published commits)

Option 3: Interactive rebase

git rebase -i HEAD~3

Mark commits to 'drop' and they're removed

Save to a branch first if unsure

git branch backup-branch

Then proceed with your undo

When in doubt: Use reflog to check git reflog — you can always recover!

Pre-Push Checklist Workflow

Easy

Scenario: Before pushing to shared branches, validate your work follows team standards.

Step 1: Check what you're about to push

git log --oneline origin/main..HEAD

See commits that will be pushed

Step 2: Review your changes

git diff origin/main..HEAD

See all code differences

Step 3: Check for forgotten debug code

git grep "console.log\|debugger\|TODO"

Step 4: Run tests locally

npm test or python -m pytest

Step 5: Update your branch from main

git fetch origin && git rebase origin/main

Step 6: Now safe to push

git push origin feature-branch

Pro tip: Create a git alias for these checks:

git config --global alias.precheck '!git log --oneline
                  origin/main..HEAD && git diff origin/main..HEAD | head'