Guide
Git Cheat Sheet is a table you can use directly: 149 commands grouped under eleven scenarios — Setup and configuration, Everyday commits, Branching, Merging and rebasing, Undo and reset, Remote collaboration, Stash, Tags, Submodules and worktrees, History and troubleshooting, and Ignore and attributes. Each entry carries a one-line explanation, an example you can paste straight into a terminal and a two-level Caution / Danger risk label, so commands that discard uncommitted changes or rewrite shared history stand out at a glance.
Updated 2026-09-094 sources10 min read
Git Cheat Sheet is a table you can use directly: 149 commands grouped under eleven scenarios — Setup and configuration, Everyday commits, Branching, Merging and rebasing, Undo and reset, Remote collaboration, Stash, Tags, Submodules and worktrees, History and troubleshooting, and Ignore and attributes. Each entry carries a one-line explanation, an example you can paste straight into a terminal and a two-level Caution / Danger risk label, so commands that discard uncommitted changes or rewrite shared history stand out at a glance.
It is made for three moments: you remember what you want to do but not how the command is spelled (search “undo commit”, “delete remote branch”); you know the command but are not sure whether it will lose anything (read the risk level and the notes); and you are new to Git and want to understand what add, commit and push actually move around (start with the four-areas diagram at the top and the operation diagrams below).
At the bottom of the page there is an in-memory Git terminal simulator: it supports 30+ common subcommands and the commit graph on the right updates live with every command, with 10 practice levels from “first commit” to “resolve a merge conflict”. It is not real Git and never touches your computer or the network, but the semantics follow the official manual, so what you practice transfers straight to a real machine.
Typing “undo commit” into the search box returns these entries from the Undo and reset group (excerpt):
Completing level 4, “undo the latest commit but keep the changes”, in the simulated terminal:
git reset --soft HEAD~1 undo the latest commit, keep the changes staged Caution
git reset HEAD~1 undo the latest commit, changes return to the working tree unstaged
git reset --hard <commit> branch pointer, index and working tree all go back to commit Danger
git revert <commit> create a new commit that cancels the change; history is untouched and it is safe to pushuser@toolun-lab:~/project (main)$ git log --oneline
7f3a1c2 (HEAD -> main) wip: messy commit
2b9e0d4 init: add README
user@toolun-lab:~/project (main)$ git reset --soft HEAD~1
HEAD is now at 2b9e0d4 init: add README
--soft: moves only the branch pointer; the index and working tree are kept (the cancelled commit's content stays staged)
Tip: the discarded commit 7f3a1c2 can still be recovered with git reflog
user@toolun-lab:~/project (main)$ git status -s
A app.js
A secret.env
✔ Passed: undo the latest commit but keep the changes.Almost every Git command can be read as “move content from one area to another”. The working tree is the files you can see and edit; the index (staging area) is a list of what the next commit will look like; the local repository (.git) holds all the commits; the remote repository is the same set of things on another machine.
With this picture in mind, many “how do I undo this” questions have a single answer: changed something that was never added — bring it back with git restore <file>; added something you do not want to commit — git restore --staged; committed and want it gone — git reset; already pushed — only git revert, which appends an inverse commit, is safe.
A commit object records a snapshot of the entire directory tree (not a diff), the ids of its parent commits, the author and the timestamps, and the message. All of that is hashed with SHA-1 (new repositories may use SHA-256) into the commit id, so any change — even one character in the message — produces a completely new id. That is why --amend, rebase and cherry-pick all “rewrite history”: they create new commits, and the old ones are simply no longer referenced.
A branch is a 40-character file under .git/refs/heads/<name> whose content is a commit id. HEAD usually points to a branch name. Creating a branch is therefore instant (writing a small file), switching branches repoints HEAD to another name and updates the working tree to that commit's snapshot, and deleting a branch just deletes a pointer — the commits themselves do not vanish immediately.
merge faithfully records what happened: the two lines meet at a merge commit, and anyone can see that the feature was developed in parallel. rebase makes the history look as though it had always been linear — git log is easier to read and git bisect is easier to use — at the cost of changing every commit id. Rule of thumb: rebase freely on your own branches that have not been pushed; merge anything others may be building on. git pull --rebase is that rule applied daily — it moves your few unpushed commits onto the remote's latest state and avoids a pile of “Merge branch 'main' of …” commits.
--soft suits “splitting or squashing commits”: the pointer goes back and the content stays staged. --mixed (the default) suits “re-choosing what to commit”. --hard is the real discard: changes in the working tree that were never committed cannot be recovered by any means, while the commits you dropped still sit in the object database — git reflog shows every move of HEAD, and git reset --hard HEAD@{1} takes you back to before the reset. By default the reflog keeps 90 days of entries (30 days for unreachable ones) — Git's window for regret.
“Danger” goes to two kinds of command: those that discard uncommitted working-tree content (restore, reset --hard, clean, stash drop, checkout -- <file>), and those that rewrite history others may already have (push --force, branch -D on an unmerged branch). “Caution” goes to commands that change state in a recoverable way or whose blast radius you should confirm first (commit --amend, rebase, merge --squash, push --delete). Read-only commands (log, diff, status, show, blame) carry no label.
git switch / git restore need version 2.23 or newer, and the older checkout spellings are listed alongside.hash-object, cat-file, update-ref and so on) and platform-specific operations (GitHub PR or GitLab MR web workflows) are not included.reset modes, linear rebase, stash, remote push and pull); interactive rebase, bisect, submodules, hooks and the full option set of configuration files are not supported, and a rebase that hits a conflict aborts automatically instead of stopping for you to resolve it..git on your computer and provides no graphical conflict resolver.Search “undo” or open the Undo and reset group, first separating “not yet pushed” (reset / --amend) from “already pushed” (revert), then pick a command. Under “Common recipes” there are complete plays such as “committed on main, want to move it to a new branch”.
git rebase -i HEAD~N with squash / fixup / reword; the rebase card in the diagram shows how the history goes from a fork to a straight line and why the old commits turn grey.
The Remote collaboration group runs from remote add to push -u and --force-with-lease; practice levels 8 (push) and 9 (undo a pushed commit) cover the two most common “cannot push” moments.
git reflog, git fsck --lost-found and git stash list sit next to each other under Undo and reset; the “recover a deleted branch” recipe gets it done in two steps.
Look at whether the commit has been pushed. Not pushed: reset drags the pointer straight back and the history stays clean. Already pushed: revert appends an inverse commit without rewriting what others already have; otherwise the next person to pull hits a fork.
Because you have unpushed commits and the remote has new ones, and a default pull merges the two sides. To avoid it, use git pull --rebase, or set git config --global pull.rebase true once.
--force overwrites the remote branch unconditionally. --force-with-lease first checks that the remote branch is still the commit you saw when you last fetched, and refuses if someone has pushed since — keeping “I overwrote a colleague's commits” from happening. Always use the latter for a push after rewriting history.
Real Git hashes content, author and timestamps together; the simulator substitutes a logical clock for real time and uses deterministic hashing, so the same sequence of operations produces the same ids, which makes checking against the reference answer easier. Its ids deliberately differ from what real Git would compute.
The commands themselves are cross-platform. The shell is what differs: in PowerShell, && needs version 7.x, quoting paths is safer, and line endings are best set via the core.autocrlf entry under Setup and configuration.
Everything on this page (the command table, the diagrams, the simulated terminal) is static content downloaded with the page and runs locally in your browser; searching, copying, adding favorites and practicing send no requests to any server. Favorites are stored in this browser's localStorage and cannot be read by the site. The external links point to the official Git documentation and are handled by those sites once clicked.
Updated 2026-09-09
149 Git commands grouped by scenario, with explanations, examples, risk levels, search, copy, favorites, diagrams, and a practice terminal
git init git init -b main # 指定初始分支名
git clone https://github.com/git/git.git git clone git@github.com:user/repo.git my-dir
git clone --depth 1 --branch v2.0 https://github.com/user/repo.git
git clone -b develop https://github.com/user/repo.git
git config --global user.name "Zhang San" git config --global user.email "zs@example.com"
git config user.email "me@company.com"
git config --list --show-origin git config --get user.name
git config --global core.autocrlf input
git config --global alias.lg "log --oneline --graph --all" git lg
Windows 通常已带 manager；macOS 用 osxkeychain 更安全。
git help rebase git reset -h # 简短用法
git status git status -s # 短格式：M 修改 A 新增 D 删除 ?? 未跟踪
git add src/app.js git add src/ # 整个目录 git add "*.md" # 通配
git add -A git add -u # 只暂存已跟踪文件的修改与删除，不含新文件
git add -p src/app.js # y 暂存这块 n 跳过 s 拆得更小 q 退出
git commit -m "fix: 修正登录超时判断"
git commit -am "docs: update readme"
容易把不想提交的改动一起带进去，提交前先 git status。
git add forgotten.js git commit --amend --no-edit # 补文件但不改说明 git commit --amend -m "新说明"
产生新的提交 id；已经推送过的提交不要 amend，否则需要强推。
git diff git diff src/app.js # 只看一个文件
git diff --staged
git diff main feature git diff HEAD~3 HEAD -- src/ git diff main...feature # feature 相对分叉点的改动
git diff --stat HEAD~1
git diff --word-diff=color README.md
git log git log -5 # 最近 5 条 git log --oneline # 一行一条
git log --oneline --graph --all --decorate
git show HEAD git show a1b2c3d --stat git show HEAD:src/app.js # 看某版本的文件内容
git rm old.txt git rm -r legacy/
git rm --cached .env echo ".env" >> .gitignore
git mv utils.js helpers.js
git branch git branch -a # 含远程分支 git branch -vv # 带最新提交与跟踪关系
git branch feature/login git branch hotfix a1b2c3d # 从指定提交创建
git switch main git switch - # 回到上一个分支
git switch -c feature/search git switch -c hotfix origin/main # 基于远程分支
git checkout -b release/1.2
git branch -m master main git push -u origin main && git push origin --delete master
git branch -d feature/login
git branch -D experiment
分支上的独有提交会成为孤儿，短期内可用 reflog 找回。
git branch --merged main git branch --no-merged # 反过来
git branch -u origin/feature/login
git branch -a --contains a1b2c3d
git checkout v1.0 git switch -c fix-from-v1 # 想保留改动就在此建分支
此状态下的提交不属于任何分支，切走后容易丢。
git branch --sort=-committerdate | head
git fetch -p git remote prune origin
git switch main git merge feature/login
git merge --no-ff feature/login
git merge --squash feature/login git commit -m "feat: login"
git merge --abort
git add src/app.js git commit # 默认说明 Merge branch ...
git checkout --theirs package-lock.json git add package-lock.json
rebase 时 ours / theirs 含义反过来：ours 是被变基到的分支。
git switch feature git rebase main
所有被搬的提交 id 都会变；已推送并有人基于它工作的分支不要 rebase。
git rebase -i HEAD~3 # pick 保留 reword 改说明 squash 并入上一条 fixup 并入且丢说明 drop 删除
git add . git rebase --continue
git rebase --abort
git rebase --onto main server client
适合「分支开错了地方」的情形。
git commit --fixup a1b2c3d git rebase -i --autosquash a1b2c3d~1
git cherry-pick a1b2c3d git cherry-pick a1b2c3d..e5f6g7h # 一段范围（不含 a1b2c3d）
git cherry-pick -n a1b2c3d
git config --global merge.tool vscode git config --global mergetool.vscode.cmd "code --wait $MERGED" git mergetool
git restore src/app.js git restore . # 整个目录
未暂存的改动会直接丢失，无法用 Git 找回。
git restore --staged src/app.js git reset HEAD src/app.js # 旧写法
git restore --source HEAD~2 config.yml git restore --source v1.0 -- src/
git reset --soft HEAD~1 git commit -m "更合适的说明"
git reset HEAD~1
git reset --hard HEAD~1 # 扔掉最后一次提交 git reset --hard origin/main # 与远程完全一致
工作区改动不可恢复；已提交的可用 git reflog 找回。
git reset package-lock.json
git revert HEAD git revert a1b2c3d --no-edit
git revert --no-commit HEAD~3..HEAD git commit -m "revert last 3 commits"
git revert -m 1 f00ba12
撤销合并后再想合入同一分支需先 revert 这个 revert。
git reflog
git reset --hard HEAD@{2} # 回到 2 步之前的状态
git branch rescue a1b2c3d # 给孤儿提交建分支git clean -n # 预览会删什么 git clean -fd # 执行 git clean -fdx # 连 .gitignore 里忽略的也删（如 node_modules）
git checkout -- src/app.js
git fsck --lost-found git show <dangling-commit-id>
git fsck --unreachable | grep commit | cut -d" " -f3 | xargs git log --merges --no-walk
git remote -v
git remote add origin git@github.com:user/repo.git
git remote set-url origin git@github.com:user/repo.git
git remote rename origin upstream
git remote remove upstream
git fetch git fetch origin main git fetch --all --prune
git pull git pull origin main
git pull --rebase origin main
git push git push origin main
git push -u origin feature/login
git push origin --delete feature/old git push origin --delete v0.1 # 也可删远程标签
git push --force-with-lease origin feature/login
优先用它而不是 --force。
git push -f origin feature/login
会抹掉别人推上去的提交；共享分支禁止。
git push --all origin
git ls-remote --heads origin git ls-remote --tags https://github.com/git/git.git
git remote add upstream https://github.com/original/repo.git git fetch upstream git switch main && git merge upstream/main
git pull --ff-only
git stash git stash push -m "登录页半成品"
git stash -u git stash -a # 连忽略文件也收
git stash list
git stash pop
git stash pop stash@{2}git stash apply stash@{1}git stash show -p stash@{0}git stash drop stash@{0}
git stash clear # 全部删除git stash branch fix-from-stash stash@{0}git stash push -m "只收起样式" -- src/styles/
git tag git tag -l "v1.*" # 按模式过滤
git tag -a v1.2.0 -m "Release 1.2.0"
git tag build-2026-09-09
git tag -a v1.1.1 a1b2c3d -m "补打"
git show v1.2.0
git tag -d v1.2.0
git push origin --delete v1.2.0
git describe --tags --always
git submodule add https://github.com/user/lib.git vendor/lib
git submodule update --init --recursive
git clone --recurse-submodules https://github.com/user/repo.git
git submodule update --remote vendor/lib git add vendor/lib && git commit -m "bump lib"
git submodule status
git submodule deinit -f vendor/lib git rm -f vendor/lib rm -rf .git/modules/vendor/lib
git worktree add ../repo-hotfix hotfix/1.2.1 git worktree add -b review ../repo-review origin/pr-42
git worktree list
git worktree remove ../repo-hotfix git worktree prune # 清理已手工删除目录的登记
git clone --filter=blob:none --sparse <url> cd repo && git sparse-checkout set apps/web packages/ui
git log -p -- src/app.js git log --follow -- src/app.js # 跨重命名跟踪
git log --grep="登录" -i --oneline
git log -S"validateToken" --oneline git log -G"regex" --oneline # 正则版
git log main..feature --oneline git log origin/main..HEAD # 还没推送的提交
git log --pretty=format:"%h %ad %an %s" --date=short -10
git log --since="2026-09-01" --until="2026-09-09" --oneline
git shortlog -sn --all --no-merges
git blame -L 40,60 src/app.js git blame -w -C src/app.js # 忽略空白、跟踪移动
git bisect start git bisect bad # 当前是坏的 git bisect good v1.1.0 # 这个版本是好的 # 反复测试并执行 git bisect good/bad git bisect reset
git bisect run npm test
git grep -n "TODO" -- "*.ts" git grep "foo" v1.0 # 在某个版本里搜
git show HEAD~5:src/config.js > old-config.js
git diff --name-only HEAD~3 HEAD git diff --name-status main # 带 M/A/D 状态
git count-objects -vH
git gc --aggressive --prune=now
prune 会真正删除不可达对象，reflog 里的后悔药会一起消失。
git rev-parse --short HEAD git rev-parse --abbrev-ref HEAD git rev-parse --show-toplevel # 仓库根目录
git archive -o release.zip v1.2.0 git archive HEAD src/ | tar -x -C /tmp/out
# .gitignore node_modules/ dist/ *.log .env* !.env.example
git check-ignore -v dist/app.js
git rm -r --cached . git add . git commit -m "chore: apply .gitignore"
echo ".DS_Store" >> ~/.gitignore_global git config --global core.excludesFile ~/.gitignore_global
git update-index --skip-worktree config/local.php git update-index --no-skip-worktree config/local.php # 取消
* text=auto *.sh text eol=lf *.png binary *.psd filter=lfs diff=lfs merge=lfs -text
git lfs install git lfs track "*.psd" git add .gitattributes
Chain a few commands into a “do one thing” recipe; expand it to copy the whole thing.
提交早了 / 说明写错 / 想拆成两个提交（且尚未推送）
git reset --soft HEAD~1提交撤掉，改动仍在暂存区git status确认文件都在「要提交的变更」里git commit -m "新的说明"别人可能已经拉取了，不能改写历史
git revert <commit>生成反向提交git push本地实验搞乱了，想彻底回到某个提交
git log --oneline找到目标提交 idgit stash -u（可选）先收起还想保留的改动git reset --hard <commit>忘了开分支就提交了 N 次
git branch feature/x在当前位置建分支（把这些提交「存」起来）git reset --hard origin/mainmain 回到远程状态git switch feature/x开 PR 之前整理历史（分支未被他人使用）
git rebase -i HEAD~4把后面几行的 pick 改成 squash 或 fixupgit push --force-with-lease分支已推送过才需要main 已经有新提交，功能分支要在其之上继续
git fetch origingit switch feature/xgit rebase origin/main或 git merge origin/main（保留合并提交）统一默认分支名
git branch -m master maingit push -u origin maingit push origin --delete master先在托管平台把默认分支切到 maingit branch -D 之后发现还有用
git reflog找到该分支最后一次提交的 id（如 "commit: xxx"）git branch <name> <commit-id>.env 或几百 MB 的文件进了历史
git rm --cached .env && echo ".env" >> .gitignore若只在最近一次提交：接着 git commit --amendgit filter-repo --path .env --invert-paths已在历史深处：用 git-filter-repo 重写全部历史（需单独安装）git push --force-with-lease --all所有协作者都要重新克隆；泄露的密钥无论如何都要作废重发main 上修好的 bug 也要进 release/1.2
git switch release/1.2git cherry-pick <commit>git pushgit merge / pull 报 CONFLICT
git status看哪些文件「双方修改」code <file>在编辑器里处理 <<<<<<< ======= >>>>>>> 标记，保留正确内容git add <file>每修好一个就 add 一个git commitrebase 时则是 git rebase --continue先在本地写了代码，后来才在 GitHub 建了仓库
git init -b main && git add -A && git commit -m "init"git remote add origin git@github.com:user/repo.gitgit push -u origin mainCircles are snapshots and arrows point to the parent, green labels are branches, purple is the branch HEAD is on; grey circles are no longer referenced by any branch (recoverable with reflog), and filled circles are the ones this action creates.
git add . && git commit -m "…"Each commit records its own parent. A branch is just a movable pointer to a commit, so committing advances main and HEAD together.
git switch -c featureThe new branch and main point at the same commit, so creating one is instant. Commits made on feature afterwards advance only feature.
git switch main && git merge featureNo new commit is created and the history stays a straight line. To keep a record that a branch once existed, merge with --no-ff instead.
git merge featureGit finds the common ancestor b2, combines the changes each side made relative to b2, and records m6 with both of them as its parents. You only get a conflict where the same area changed differently.
git switch feature && git rebase mainThe history becomes a straight line, but c3 and d4 are replaced by new commits c3′ and d4′ with different ids. Never rebase a branch you have already pushed, or everyone else's history will diverge from yours.
git reset --hard HEAD~1--soft moves only the pointer; --mixed also updates the index; --hard overwrites the working tree as well. The orphaned commit c3 is still recoverable from the reflog, which keeps entries for at least 30 days by default.
git revert HEADc3 stays in the history. The new commit r4 contains the inverse of what c3 changed. Use this rather than reset when the commit has already been pushed.
git cherry-pick x7Replays the change x7 introduced relative to its parent onto main, producing x7′ with the same content and a different id. This is the usual way to carry a single fix to a release branch.
A purely in-memory Git simulator (not real Git, and it never goes online): it supports the common subcommands init / add / commit / branch / switch / merge / rebase / reset / revert / stash / tag / remote / push / pull, and the graph on the right updates live. 10 levels run from "the very first one" to "resolving a conflict". Linux command practice is inthe Linux command reference.