Name	Name	Last commit message	Last commit date
Latest commit History 7 Commits
README.md	README.md

Cheat sheet

A cheatsheet of commands for my workflow.

Quick Reference

Most frequently used commands for daily Git workflow.

git status – check what's changed
git add . – stage all changes
git commit -m "msg" – commit changes
git push – push to remote
git pull – update from remote
git log --oneline --graph --decorate --all – view history
git branch -av – list branches
git switch – switch branches

Local Navigation (Shell)

Basic commands to move around directories and view files in your terminal.

cd – go to home
cd ~/Desktop – absolute path
cd .. – up one directory
pwd – print current path
ls – names
ls -la – incl. hidden + details

Inspect Repo State

Check what files have changed, what's staged, and view differences before committing.

git status – what's changed/staged?
git status -sb – short, with branch
git diff – unstaged changes
git diff --staged – staged changes

Working with an Existing Repo

Commands to clone a repository, view remotes, and sync with the remote repository.

git clone – HTTPS or SSH
cd
git remote -v – view remotes
git fetch – update refs (no merge)
git pull – fetch + merge (or rebase; see config below)

Day-to-Day: Add, Commit, Push

The core workflow for saving your changes: stage files, commit them, and push to remote.

git add . – stage all modified/new files
git add -p – stage hunks interactively
git commit -m "meaningful msg" – commit staged changes
git commit --amend – fix the last commit message or add missed files
git commit --amend --no-edit – add files to last commit without changing message
git push -u origin – first push; sets upstream
git push – subsequent pushes
git pull --rebase – pull with rebase instead of merge

Starting a Brand-New Repo

Initialize a new Git repository and connect it to a remote repository for the first time.

git init
git add --all
git commit -m "initial commit"
git branch -M main – (optional) rename to main
git remote add origin
git push -u origin main

Branching & Switching

Create and switch between branches to work on features or fixes in isolation.

git branch -av – list local & remote branches
git branch – create branch
git checkout – switch (old syntax)
git switch – switch (newer, nicer)
git switch -c – create + switch
git branch -d – delete merged branch (safe)
git branch -D – force delete branch (unsafe, use with caution)

Merging (Safe Workflow)

Safely integrate changes from one branch into another, keeping a clean history.

git checkout main
git pull --ff-only – update main safely
git checkout
git merge main – bring latest main into feature
git checkout main
git merge – merge feature into main
git push

Rebasing (Optional)

Reapply your commits on top of the latest main branch for a linear history, useful before merging.

git checkout
git fetch origin
git rebase origin/main – rebase feature on latest main
git add – resolve conflicts if needed
git rebase --continue – continue after fixing conflicts
git rebase --abort – cancel rebase if needed
git push --force-with-lease – ⚠️ Only force push if rebasing (never on shared branches)

Stashing

Temporarily save uncommitted changes so you can switch branches or pull updates without committing.

git stash – stash tracked changes
git stash -u – include untracked
git stash list – list all stashes
git stash pop – restore & remove from stash
git stash apply – restore but keep in stash
git stash drop – delete a stash entry
git stash clear – delete all stashes

Undo & Recover

Revert changes, unstage files, undo commits, or recover lost work using reflog.

git restore – discard unstaged changes
git checkout -- – older syntax
git reset HEAD – unstage a staged file
git reset --soft HEAD~1 – undo commit, keep staged
git reset --mixed HEAD~1 – undo commit, keep changes unstaged
git reset --hard HEAD~1 – ⚠️ DESTRUCTIVE: undo commit AND changes (use with caution)
git revert – make a new commit that undoes (safe for shared branches)
git reflog – find lost commits & HEAD moves
git reflog show – show reflog for specific branch

Logs & History

View commit history, see who changed what in a file, and inspect specific commits.

git log --oneline --graph --decorate --all – compact visual history
git log -p – show patches (full diffs)
git log --stat – show file stats (additions/deletions)
git log --follow – track file through renames
git log --oneline – commits on specific branch
git blame – see who changed each line
git show – inspect specific commit

Comparing Things

Compare differences between branches, commits, or files to see what changed.

git diff .. – compare two branches
git diff HEAD – compare working directory to last commit
git diff --name-only HEAD~1 – show only changed filenames
git diff – compare two specific commits

Tags (Releases)

Mark specific commits as release versions for easy reference and deployment.

git tag v1.0.0
git tag -a v1.0.0 -m "msg"
git push origin v1.0.0
git push --tags

Remotes

Manage connections to remote repositories, including adding, updating, and syncing remote branches.

git remote -v – view all remotes
git remote add origin – add remote
git remote set-url origin – update remote URL
git remote remove – remove a remote
git remote show origin – detailed remote info
git fetch origin --prune – fetch and remove deleted remote branches

.gitignore Example

Example patterns to exclude files and directories from being tracked by Git. node_modules/ *.log .env .DS_Store

To apply .gitignore after adding files:

Remove already-tracked files from Git's index so .gitignore rules take effect.

git rm -r --cached .
git add .
git commit -m "apply .gitignore"

Useful Config

Set up your Git identity and configure default behaviors to streamline your workflow.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global pull.rebase true – use rebase instead of merge for pulls
git config --global init.defaultBranch main – default branch name
git config --global alias.lg "log --oneline --graph --decorate --all" – custom log alias
git config --global core.editor "code --wait" – set VS Code as editor (or vim, nano, etc.)

Safety Notes

Important warnings and best practices to avoid losing work.

⚠️ Destructive Commands (Use with Caution):

git reset --hard – permanently deletes uncommitted changes
git push --force – overwrites remote history (use --force-with-lease instead)
git clean -fd – permanently deletes untracked files
git branch -D – force deletes branch even if not merged

✅ Safe Practices:

Always use --force-with-lease instead of --force when pushing
Use git revert on shared branches instead of git reset
Check git status before destructive operations
Use git reflog to recover lost commits
Stash changes before switching branches if unsure

Cherry-Picking

Apply a specific commit from another branch to your current branch.

git cherry-pick – apply commit to current branch
git cherry-pick – pick multiple commits
git cherry-pick --abort – cancel cherry-pick if conflicts occur

Cleaning Up

Remove untracked files and delete branches that are no longer needed.

git clean -n – preview untracked files to be removed (dry run)
git clean -fd – remove untracked files and directories
git clean -fX – remove only files ignored by .gitignore

Common Fixes for Push

Troubleshoot and fix common issues when pushing to remote, like branch name mismatches or conflicts.

Upstream tracking issues:

git push -u origin – set upstream and push

Branch name fixes:

git branch -m – rename branch locally
git push origin : – delete old remote, push new
git push -u origin – set upstream for new branch

Sync with remote:

git fetch origin – update remote refs
git rebase origin/main – rebase on latest main
git pull --rebase – pull with rebase

⚠️ Force push safety:

git push --force-with-lease – safer than --force (checks remote first)
git push --force – ⚠️ DANGEROUS: overwrites remote (avoid on shared branches)

Troubleshooting

Common issues and their solutions when things go wrong.

"Your branch is behind origin/main":

git fetch origin
git rebase origin/main (or git merge origin/main)

"Updates were rejected because the tip of your current branch is behind":

git pull --rebase (preferred)
git pull (creates merge commit)

Accidentally committed to wrong branch:

git reset --soft HEAD~1 (undo commit, keep changes)
git stash (save changes)
git switch
git stash pop (restore changes)

Lost a commit:

git reflog – find the commit hash
git cherry-pick – restore it

Merge conflicts:

git status – see conflicted files
Edit files to resolve conflicts
git add
git commit (or git rebase --continue if rebasing)

1980computer/cheat-sheet-terminal

Folders and files

Latest commit

History

Repository files navigation