Git Cheatsheet - Command Reference

Git essentials organized into Commit, Branch, Revert, Remote, and History groups: fix a bad commit with amend/restore/reset, untangle branches with reflog/switch/rebase, inspect changes with git log. Each command notes when to use it and when to be careful.

Version Control·44 commands·Last updated 2026-07-21

Commit & Stash 6

git status -s

Quick view of working tree status

git add -p

Interactively stage changes hunk by hunk

git commit -m "msg"

Commit staged changes

git commit --amend

Amend the last commit (message or content)

git stash

Temporarily save changes, useful for switching branches

git stash pop

Restore the most recent stash

Branch & Merge 13

git branch -a

List local and remote branches

git branch -vv

Show local vs remote branch tracking

git switch -c feat/x

Create and switch to a new branch (new syntax)

git merge --no-ff feat/x

Merge branch and preserve merge commit

git rebase main

Rebase current branch onto main for linear history

git rebase -i HEAD~3

Interactive rebase: squash or rewrite last 3 commits

git rebase --abort

Abort the rebase and return to the pre-rebase state

git cherry-pick <sha>

Apply a specific commit to the current branch

git push -u origin feat/x

Push and set upstream, then just git push

git push origin --delete feat/x

Delete a remote branch

git branch -d feat/x

Delete a merged branch

git branch -D feat/x

Force-delete an unmerged branch (use with caution)

git branch --merged

List branches already merged into the current branch

Revert & Undo 5

git restore <file>

Discard working tree changes (new syntax)

git restore --staged <file>

Unstage a file, keep changes

git reset --soft HEAD~1

Undo last commit, keep changes staged

git reset --hard HEAD~1

Discard last commit and changes entirely, use with caution

git revert <sha>

Create a reverse commit to undo changes, safe for shared branches

Remote & Diagnostics 5

git remote -v

View remote repository URLs

git fetch --prune

Fetch and prune deleted remote branch references

git log --oneline --graph

Graphical commit history view

git reflog

View HEAD movement history, lifesaver for recovering lost commits

git blame <file>

Annotate file line by line with last author and commit

Commit History (git log) 10

git log -p

Show the full diff of each commit

git log --stat

Show file change statistics per commit

git log --author="Alice"

Filter commits by author

git log --since="2 weeks ago"

Show commits from the last two weeks

git log --grep="fix"

Filter commits by message keyword

git log -S "function_name"

Find commits that add or remove that string (pickaxe)

git log origin/main..HEAD

Show local commits not yet pushed

git log --follow -- file.js

Follow a file's full history including renames

git log --name-status

Show changed file names and status (A/M/D)

git shortlog -sn

Count commits by author

FAQ 5

Q: How do I undo the last commit?

A: git reset --soft HEAD~1 keeps changes staged; git reset --hard HEAD~1 discards them (use with caution). For pushed commits use git revert <sha>.

Q: What is the difference between git merge and git rebase?

A: merge preserves branch history (creates a merge commit) and suits shared branches; rebase linearizes history (rewrites commits) and suits personal cleanup.

Q: How do I change the last commit message?

A: git commit --amend edits the last commit message or content. If already pushed, use git push --force-with-lease and mind team safety.

Q: How do I stash unfinished changes?

A: git stash saves working tree changes; after switching branches use git stash pop to restore. git stash list shows all stashes.

Q: How do I resolve a merge conflict?

A: Conflicted files are marked with <<<<<<< HEAD and >>>>>>> branch. Edit manually, then git add <file> and git commit to finish.

Typical Use Case

For solo or small-team repos, Git daily work boils down to three recurring scenarios: quietly redoing a wrong commit, merging parallel branches, and tracing history. Working on a feature branch you make 3 commits and notice the first message is wrong — use git rebase -i to rewrite it. Before merging to main, git fetch + git rebase keeps a linear history, then git merge --no-ff preserves a merge node. When a bug ships, git log -S pins down which commit introduced the code. Master these three flows and collaboration stops being frantic.

Command Examples

Recover a commit dropped by reset

git reset --hard HEAD~2\ngit reflog\ngit reset --hard HEAD@{2}

reset --hard 后工作区被清空，但只要没跑 gc，reflog 仍记录每次 HEAD 移动，用 HEAD@{n} 就能找回上一位置。

Output

ba9c3e1 (HEAD) fix: drop temp debug log   <- reflog 里的历史 HEAD\n8f10a42 feat: add pagination\nHEAD@{2}: reset: moving to HEAD~2

Cherry-pick a single commit

git log --oneline -3\ngit cherry-pick 9f2c14b

想只拿另一个分支的某个提交，而不合并整个分支时用 cherry-pick；有冲突时按提示解决后 git cherry-pick --continue。

Common Pitfalls

git push origin --delete and git branch -D are irreversible — verify with git branch -a and git log before deleting.
Resetting a commit already pushed to a shared branch then force-pushing overwrites teammates' history; use revert on shared commits.
git clean -fd (not listed here) deletes untracked files unrecoverably — always preview with git clean -n first.
git stash does not include untracked files by default; use git stash -u to include them.

Tips

reset --hard discards changes — double-check before running; use git reflog to recover if truly lost.
Use revert to undo commits already pushed to shared branches — never reset and force-push or you will break your teammates.
switch/restore are newer commands with clearer semantics than checkout; older scripts still use checkout.

FAQ

When should I use git rebase vs git merge?

merge preserves divergent history and creates a merge commit, so it suits shared branches such as merging a feature into main, is easy to roll back as a unit, and never rewrites existing commits. rebase replays your commits onto the target branch to produce a clean linear history, which is great for tidying your own feature branch, but it rewrites commits and should be avoided on branches others share.

Can I undo an already-pushed commit with git reset and then force-push?

Not recommended. reset rewrites history, and force-pushing it can overwrite teammates commits, causing conflicts or lost work. For pushed commits, safely undo with git revert <sha>, which creates a reverse commit. It is fine to use reset --soft/hard only while the commit is still local and unpushed.

I accidentally committed node_modules or .env. How do I remove them?

Run git rm --cached <path> to stop tracking while keeping the file locally, add the rule to .gitignore, then commit once. This only removes the files from version control without deleting them from disk. If a secret was exposed, also rewrite history and rotate the credential.

Can I recover a deleted branch or a commit dropped by reset?

Yes. Unless gc has run, git reflog records every prior position of HEAD and branches; restore with git reset --hard HEAD@{n} or git checkout -b <name> <sha>. If a deleted branch still has its commits, find the sha with git reflog and recreate the branch.

My git stash changes suddenly disappeared?

First check git stash list, and inspect contents with git stash show -p stash@{0}. A pop may leave conflicts that appear as conflict markers you must resolve manually. If it is really gone, use git fsck --lost-found to recover the unreferenced stash commit from the object database. Note git stash does not include untracked files unless you use git stash -u.

Official References

Each command links to its official documentation below, so you can verify the latest usage and read deeper.

Git Docs

Maintained by LaoHand

Publicly updated on Jul 21, 2026, continuously proofread against official docs.

Contact Us

Wrong command or description? Send us corrections, business inquiries or product feedback by email.